chap02.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN"
"http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd"
[
<!ENTITY BASEID "djangobook.chap02">
]>

<chapter lang="ru" id="&BASEID;">

  <title id="&BASEID;.title">
    Начинаем
  </title>

  <para>
    Перевод &copy; Попов Руслан &lt;ruslan.popov &bull; gmail&gt;
  </para>

  <para>
    Установка Django является многошаговым процессом из-за множества
    изменяющихся частей современной среды веб разработки. В этой главе
    мы расскажем о том, как установить среду и некоторые её
    зависимости.
  </para>

  <para>
    Из-за того, что Django является <quote>просто</quote> кодом на
    языке Python, она работает везде, где есть интерпретатор Python,
    даже на некоторых мобильных телефонах! Но данная глава описывает
    только общие сценарии установки Django. Мы предполагаем, что вы
    устанавливаете её на свой компьютер или на сервер.
  </para>

  <para>
    Позднее, в главе <quote><xref linkend="djangobook.chap20"
    endterm="djangobook.chap20.title"/></quote>, мы расскажем как
    установить Django на боевой сервер.
  </para>

  <section id="&BASEID;.install-python">

    <title id="&BASEID;.install-python.title">
      Установка Python
    </title>

    <para>
      Сама среда Django написана на чистом Python, следовательно,
      первым шагом при установке среды надо удостовериться, что
      интерпретатор языка Python установлен.
    </para>

    <section id="&BASEID;.install-python.versions">

      <title id="&BASEID;.install-python.versions.title">
	    Версии Python
      </title>

      <para>
	    Ядро среды Django работает с любыми версиями Python в
	    диапазоне от 2.3 до 2.7 включительно. Необязательный компонент
	    GIS может работать с версиями от 2.4 до 2.7.
      </para>

      <para>
	    Если вы не уверены в том, какая именно версия интерпретатора
	    языка Python следует установить и у вас есть полная свобода
	    выбора, возьмите последнюю версию из ветки 2.х: т.е. версию
	    2.7. Несмотря на то, что Django работает одинаково хорошо с
	    любой из вышеперечисленных версий, последняя версия
	    интерпретатора Python обладает лучшей производительностью и
	    дополнительными возможностями диалекта языка, которыми вы
	    сможете воспользоваться при разработке своих
	    приложений. Дополнительно, некоторые компоненты среды от
	    сторонних разработчиков, которыми вы возможно захотите
	    воспользоваться, могут потребовать более новую версию, чем
	    Python 2.3, таким образом, использование последней версии
	    интерпретатора даст вам больший выбор.

	    <note>
	      <title>Django и Python 3.0</title>

	      <para>
	        Во время написания книги был выпущен Python 3.0, но Django
	        пока не поддерживает его. Python 3.0 имеет значительное
	        число обратно-несовместимых изменений самого языка и, как
	        результат, мы ожидаем, что большинству основных библиотек
	        языка и сред, включая Django, потребуется несколько лет на
	        этот переход.
	      </para>

	      <para>
	        Если вы новичок в мире Python и раздумываете, что изучать
	        &mdash; Python 2.x или Python 3.x, мы посоветуем
	        остановиться на Python 2.x.
	      </para>
	    </note>
      </para>

    </section>

    <section id="&BASEID;.install-python.installation">

      <title id="&BASEID;.install-python.installation.title">
	    Установка
      </title>

      <para>
	    Если вы используете Linux или Mac OS X, вероятно у вас уже
	    установлен Python. Наберите <token>python</token> в командной
	    строке или в терминале (Application/Utilities/Terminal) на OS
	    X). Если вы увидите нечто подобное, значит Python установлен:
	    <screen>
	      <![CDATA[
Python 2.4.1 (#2, Mar 31 2005, 00:05:10)
[GCC 3.3 20030304 (Apple Computer, Inc. build 1666)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>
          ]]>
	    </screen>
      </para>

      <para>
        В противном случае вам потребуется скачать и установить
        Python. Это легко и просто, а подробные инструкции доступны на
        <ulink url="http://www.python.org/download/"/>.
      </para>

    </section>

  </section>

  <section id="&BASEID;.install-django">

    <title id="&BASEID;.install-django.title">
      Установка Django
    </title>

    <para>
      В любое время вам доступны две различные версии Django:
      последний официальный релиз и версия из
      <quote>транка</quote>. Версия, которую вы решите установить,
      зависит от ваших приоритетов. Вы желаете использовать стабильную
      и проверенную версию Django или вы желаете использовать версию,
      содержащую последние наработки, возможно вы будете
      совершенствовать саму Django, в ущерб стабильности?
    </para>

    <para>
      Мы рекомендуем придерживаться официального релиза, но важно
      знать, что существует версия для разработчиков, так как вы
      найдёте упоминания о ней в документации и в сообществе.
    </para>

    <section id="&BASEID;.install-django-release">

      <title id="&BASEID;.install-django-release.title">
        Установка официального релиза
      </title>

      <para>
        Официальные релизы имеют имена версий подобные 1.0.3 или 1.1,
        а последный релиз всегда доступен на <ulink
        url="http://www.djangoproject.com/download/"/>. Для его
        установки, сначала надо скачать архив, который будет иметь имя
        подобное
        <filename>Django-1.0.2-final.tar.gz</filename>. Затем, надо
        развернуть архив и запустить <command>setup.py
        install</command>, как вы это делаете с большинством библиотек
        Python.
      </para>

      <para>
        Ниже показано как этот процесс выглядит на Unix системах:
        <orderedlist>
          <listitem>
            <para>
              <command>tar xzvf Django-1.0.2-final.tar.gz</command>
            </para>
          </listitem>

          <listitem>
            <para>
              <command>cd Django-*</command>
            </para>
          </listitem>

          <listitem>
            <para>
	      <command>sudo python setup.py install</command>
            </para>
          </listitem>
        </orderedlist>
      </para>

      <para>
        Если вы используете дистрибутив Linux, который содержит пакет
        с Django, будет хорошей идеей воспользоваться этим
        пакетом. Это позволит вам получать критические обновления
        совместно с остальными пакетами системы.
      </para>

      <para>
        На Windows мы рекомендуем использовать 7-Zip (<ulink
        url="http://www.djangoproject.com/r/7zip/"/>) для распаковки
        <filename>.tar.gz</filename> файлов. После распаковки
        запустите DOS оболочку (<quote>Command Prompt</quote>) с
        административными привелегиями и выполните следующую команду в
        каталоге, имя которого начинается с
        <filename>Django-</filename>:
        <screen>
          <![CDATA[
python setup.py install
          ]]>
        </screen>
      </para>

    </section>

    <section id="&BASEID;.install-trunk-version">

      <title id="&BASEID;.install-trunk-version.title">
        Установка версии из транка
      </title>

      <para>
        Самая последняя версия Django называется <emphasis>стволом
        (trunk)</emphasis> и она доступна из Subversion репозитория
        Django. Вы должны рассмотреть возможность установки этой
        версии, если вам требуется работать с новыми возможностями или
        если вы желаете совершенствовать Django.
      </para>

      <para>
        Subversion &mdash; это свободная система управления версиями с
        открытым исходным кодом, подобная CVS.  Команда разработчиков
        Django использует её для управления базой разрабатываемого
        кода. Вы можете использовать клиент Subversion для получения
        свежего исходного кода Django и в любое время вы можете
        обновлять свою версию кода для получения свежих обновлений от
        других разработчиков.
      </para>

      <para>
        Используя код со ствола, следует помнить, что нет гарантий
        того, что всё в Django работоспособно на данный
        момент. Несмотря на это команда разработчиков использует ствол
        для работы своих сайтов и борется за их стабильную работу.
      </para>

      <para>
        Для получения кода со ствола делайте так:
        <orderedlist>
          <listitem>
            <para>
              Удостоверьтесь, что у вас установлен клиент
              Subversion. Вы можете свободно получить его на <ulink
              url="http://subversion.tigris.org/"/> и вы можете найти
              отличную документацию на <ulink
              url="http://svnbook.red-bean.com/"/>.
            </para>
          </listitem>

          <listitem>
            <para>
              Получите код с помощью команды:
              <screen>
svn co http://code.djangoproject.com/svn/django/trunk djtrunk
              </screen>
            </para>
          </listitem>

          <listitem>
            <para>
              Создайте файл
              <filename>site-packages/django.pth</filename> и добавьте
              в него каталог <token>djtrunk</token> или обновите ваш
              <varname>PYTHONPATH</varname>, чтобы он указывал на
              <filename>djtrunk</filename>.
            </para>
          </listitem>

          <listitem>
            <para>
              Поместите путь <filename>djtrunk/django/bin</filename> в
              ваш системный <varname>PATH</varname>. Этот каталог
              содержит утилиты управления, такие как
              <filename>django-admin.py</filename>.
            </para>
          </listitem>
        </orderedlist>
        <note>
          <title>
            Совет
          </title>

          <para>
            Если вы не знакомы с файлами <filename>.pth</filename>, вы
            можете почитать о них на <ulink
            url="http://www.djangoproject.com/r/python/site-module/"/>.
          </para>
        </note>
      </para>

      <para>
        После получения кода и выполнения вышеприведённых шагов нет
        никакой необходимости выполнять команду:
        <screen>
python setup.py install
        </screen>
        Все необходимые действия вы уже проделали вручную!
      </para>

      <para>
        Из-за того, что ствол Django обновляется часто, для
        исправления ошибок и добавления новых возможностей, вероятно
        вы пожелаете обновлять его на регулярной основе. Для
        обновления исходного кода надо просто в каталоге
        <filename>djtrunk</filename> выполнить команду:
        <screen>
svn update
        </screen>
      </para>

      <para>
        При выполнении этой команды, Subversion подключается к <ulink
        url="http://code.djangoproject.com"/>, определяет наличие
        изменений кода Django и обновляет вашу локальную версию кода,
        скачивая только изменения. Это достаточно быстро.
      </para>

      <para>
        Наконец, если вы используете код из ствола, вы должны знать
        как определить номер текущей версии кода, на которым вы
        работаете. Знание номера версия имеет ключевое значение, если
        вам понадобится помощь от сообщества пользователей Django или
        если вы соберётесь усовершенствовать среду. В этих случаях вам
        потребуется указать версию кода, так же известную как
        <quote>номер ревизии</quote>, которую вы используете. Для
        того, чтобы узнать номер ревизии, наберите <command>svn
        info</command> каталоге с кодом Django и посмотрите на строчку
        с текстом <quote>Revision:</quote>. Этот номер увеличивается
        при каждом изменении в коде Django, будь то исправлением
        ошибки, добавлением новых возможностей, изменением в
        документации или чем-то ещё. Некоторые пользователи Django
        измеряют свою крутость, говоря: <quote>Я пользуюсь Django с
        версии [вставьте тут номер ревизии поменьше].</quote>.
      </para>

    </section>

  </section>

  <section id="&BASEID;.testing-django">

    <title id="&BASEID;.testing-django.title">
      Проверка установки Django
    </title>

    <para>
      После установки Django потратьте немного времени для проверки её
      работоспособности. В терминале перейдите в другой каталог (т.е.,
      не в тот, который содержит каталог <filename>django</filename>)
      и запустите интерпретатор Python, набрав
      <command>python</command>. Если всё установлено правильно, вы
      должны иметь возможность импортировать модуль
      <token>django</token>:
      <screen>
        <![CDATA[
>>> import django
>>> django.VERSION
(1, 1, 0, 'alpha', 0)
        ]]>
      </screen>

      <note>
        <title>
          Примеры интерактивного интерпретатора
        </title>

        <para>
          Интерактивный интерпретатор языка Python является программой
          командной строки, которая позволяет вам выполнять
          программы. Для запуска интерпретатора просто выполните в
          командной строке команду <command>python</command>.
        </para>

        <para>
          Во всей книге мы будем приводить код на языке Python как
          если бы он вводился в интерактивный интерпретатор. Вы
          сможете распознать эти примеры по трём знакам
          <quote>больше</quote> (<![CDATA[>>>]]>), которые являются
          приглашением интерпретатора. Если вы будете копировать
          примеры из книги, не копируйте эти знаки.
        </para>

        <para>
          Многострочные команды в интерактивном интерпретаторе
          выравниваются с помощью трёх точек (<token>...</token>), вот
          так:
          <screen>
            <![CDATA[
>>> print """This is a
... string that spans
... three lines."""
This is a
string that spans
three lines.
>>> def my_function(value):
...     print value
>>> my_function('hello')
hello
            ]]>
          </screen>
        </para>

        <para>
          Эти три точки в начале дополнительных строк добавляются
          интерпретатором, они не являются частью нашего ввода. Мы не
          убираем их, чтобы сымитировать вывод интерпретатора. Если вы
          будете копировать наши примеры, не копируйте эти точки.
        </para>
      </note>
    </para>

  </section>

  <section id="&BASEID;.setdb">

    <title id="&BASEID;.setdb.title">
      Настройка базы данных
    </title>

    <para>
      На данный момент вы можете начать разработку веб приложения на
      Django, потому что единственное требование Django &mdash;
      работающий экземпляр интерпретатора Python. Тем не менее, эта
      книга сфокусирована на одной из возможностей среды разработки, а
      именно на разработке сайтов с поддержкой базы
      данных. Следовательно, вам потребуется установить сервер базы
      данных, который будет хранить ваши данные.
    </para>

    <para>
      Если вы просто желаете посмотреть Django, пропустите всё до
      раздела <quote><xref linkend="&BASEID;.startproject"
      endterm="&BASEID;.startproject.title"/></quote>. Но имейте в
      виду, что все примеры в книге предполагают, что у вас есть база
      данных.
    </para>

    <para>
      Django поддерживает четыре системы управления базами данных:
      <itemizedlist>
        <listitem>
          <para>
            PostgreSQL (<ulink url="http://www.postgresql.org/"/>).
          </para>
        </listitem>

        <listitem>
          <para>
            SQLite 3 (<ulink url="http://www.sqlite.org/"/>).
          </para>
        </listitem>

        <listitem>
          <para>
            MySQL (<ulink url="http://www.mysql.com/"/>).
          </para>
        </listitem>

        <listitem>
          <para>
            Oracle (<ulink url="http://www.oracle.com/"/>).
          </para>
        </listitem>
      </itemizedlist>
    </para>

    <para>
      По большей части движки для перечисленных баз данных хорошо
      работают с ядром среды Django. Заметным исключением является
      необязательная поддержка GIS, которая лучше работает совместно с
      PostgreSQL, чем с другими базами данных. Если вы не привязаны к
      какой-либо унаследованной системе и у вас есть свобода выбора
      базы данных, мы рекомендуем PostgreSQL, который имеет отличный
      баланс между стоимостью, возможностями, скоростью и
      стабильностью.
    </para>

    <para>
      Настройка базы данных происходит в два шага:
      <itemizedlist>
        <listitem>
          <para>
            Во-первых, вам потребуется установить и настроить сам
            сервер базы данных. Этот процесс не попадает в область
            рассмотрения данной книги, но каждая из упомянутых баз
            данных имеет хорошую документацию на собственном
            сайте. Если вы используете сторонних хостинг, наверняка,
            его администраторы уже настроили всё для вас.
          </para>
        </listitem>

        <listitem>
          <para>
            Во-вторых, вам потребуется установить библиотеку Python
            для поддержки вашей базы данных. Это сторонний код,
            который позволяет Python получать интерфейс к базе
            данных. Мы рассмотрим требования каждой базы данных в
            следующих разделах.
          </para>
        </listitem>
      </itemizedlist>
    </para>

    <para>
      Если вы только начали разбираться с Django и не желаете
      устанавливать сервер баз данных, рассмотрите возможность
      использования SQLite. SQLite отличается от всех остальных баз
      данных, упомянутых выше, тем, что он не требует вышеописанных
      шагов, если вы используете Python 2.5. SQLite просто читает и
      пишет данные в единственный файл на файловой системе, а Python
      2.5 имеет встроенную поддержку для него.
    </para>

    <para>
      На Windows получение драйвера для работы с базой данных является
      не таким простым процессом. Таким образом, мы рекомендуем
      начинать работу с Django, используя Python версии 2.5 и его
      поддержку SQLite.
    </para>

    <section id="&BASEID;.setdb.pgsql">

      <title id="&BASEID;.setdb.pgsql.title">
        Использование Django с PostgreSQL
      </title>

      <para>
        Если вы планируете использовать PostgreSQL, вам потребуется
        пакет <token>psycopg</token> или <token>psycopg2</token>,
        которые можно получить с <ulink
        url="http://www.djangoproject.com/r/python-pgsql/"/>. Мы
        рекомендуем использовать <token>psycopg2</token>, так как она
        новее и более активно разрабатывается и может быть легко
        установлена. В любом случае следует запомнить, какую версию вы
        используете, 1-ую или 2-ую, информация об этом потребуется
        далее.
      </para>

      <para>
        Если вы используете PostgreSQL на Windows, вы можете найти
        собранную версию пакета <token>psycopg</token> на <ulink
        url="http://www.djangoproject.com/r/python-pgsql/windows/"/>.
      </para>

      <para>
        Если вы используете Linux, проверьте через пакетную систему
        вашего дистрибутива наличие пакета с именем
        <filename>python-psycopg2</filename>,
        <filename>psycopg2-python</filename>,
        <filename>python-postgresql</filename> или аналогичным им.
      </para>

    </section>

    <section id="&BASEID;.setdb.sqlite3">

      <title id="&BASEID;.setdb.sqlite3.title">
        Использование Django с SQLite 3
      </title>

      <para>
        Если вы используете интерпретатор Python версии 2.5 или выше,
        вам повезло: никакой установки вам не потребуется, так как
        Python уже содержит поддержку SQLite. Переходите к чтению
        следующего раздела.
      </para>

      <para>
        Если вы используете Python 2.4 или старее, вам потребуется
        SQLite версии 3 (<emphasis>не</emphasis> 2-ой) с <ulink
        url="http://www.djangoproject.com/r/sqlite/"/> и пакет
        <token>pysqlite</token> с <ulink
        url="http://www.djangoproject.com/r/python-sqlite/"/>. Удостоверьтесь,
        что у вас установлен пакет <token>pysqlite</token> версии не
        ниже 2.0.3.
      </para>

      <para>
        На Windows вы можете пропустить установку отдельных
        исполняемых файлов SQLite, так как они статически слинкованы с
        <token>pysqlite</token>.
      </para>

      <para>
        Если вы используете Linux, проверьте через пакетную систему
        вашего дистрибутива наличие пакета с именем
        <filename>python-sqlite3</filename>,
        <filename>sqlite-python</filename>,
        <filename>pysqlite</filename> или аналогичным им.
      </para>

      <para>
        Например, на Debian Linux, Ubuntu и т.д. этот пакет можно
        поставить так:
        <screen>
          <![CDATA[
apt-get install python-pysqlite2
          ]]>
        </screen>
      </para>

    </section>

    <section id="&BASEID;.setdb.mysql">

      <title id="&BASEID;.setdb.mysql.title">
        Использование Django с MySQL
      </title>

      <para>
        Django работает с MySQL, начиная с версии 4.0. Версии MySQL
        ниже 4.0 не поддерживают вложенные запросы и некоторые
        стандартные SQL операторы.
      </para>

      <para>
        Вам также потребуется установить пакет <token>MySQLdb</token>
        с <ulink url="http://www.djangoproject.com/r/python-mysql/"/>.
      </para>

      <para>
        Если вы используете Linux, проверьте через пакетную систему
        вашего дистрибутива наличие пакета с именем
        <filename>python-mysql</filename>,
        <filename>python-mysqldb</filename>,
        <filename>mysql-python</filename> или аналогичным им.
      </para>

    </section>

    <section id="&BASEID;.setdb.nodb">

      <title id="&BASEID;.setdb.nodb.title">
        Использование Django без базы данных
      </title>

      <para>
        Как упоминалось ранее, Django не требует наличия базы
        данных. Если вы просто желаете обрабатывать динамические
        страницы, которые не обращаются к базе данных, всё это
        реально.
      </para>

      <para>
        Следует принять во внимание, что некоторые дополнительные
        инструменты поставляемые с Django <emphasis>требуют</emphasis>
        наличия базы данных. Соответственно, если вы отказываетесь от
        использования базы данных, вы также отказываетесь от
        использования этих инструментов. Мы отдельно выделим их в
        книге.
      </para>

    </section>

  </section>

  <section id="&BASEID;.startproject">

    <title id="&BASEID;.startproject.title">
      Новый проект
    </title>

    <para>
      После того как вы установили Python, Django и (возможно) сервер
      баз данных и библиотеку Python для него, вы можете сделать
      первый шаг в разработке веб приложения, создав
      <emphasis>проект</emphasis>.
    </para>

    <para>
      <emphasis>Проектом</emphasis> является набор настроек для
      экземпляра Django, включая конфигурацию базы данных, параметров
      для Django и настроек приложения.
    </para>

    <para>
      Если вы используете Django в первый раз, вам потребуется
      позаботиться об инициализации проекта. Создайте новый каталог в
      котором вы будете работать, например,
      <filename>/home/username/djcode/</filename>.

      <note>
        <title>
          Где должен располагаться этот каталог
        </title>

        <para>
          Если вы раньше использовали PHP, вы вероятно размещали код в
          корневом каталоге веб сервера (например, в
          <filename>/var/www</filename>). При использовании Django так
          делать не следует. Это плохая идея размещать код в таком
          месте, потому что есть риск доступа сторонних лиц к вашему
          коду. Это плохо.
        </para>

        <para>
          Разместите ваш код в каком-нибудь каталоге
          <emphasis>вне</emphasis> корневого каталога веб сервера.
        </para>
      </note>
    </para>

    <para>
      Перейдите в созданный каталог и выполните команду
      <command>django-admin.py startproject mysite</command>. Она
      создаст каталог <filename>mysite</filename> в текущем каталоге.

      <note>
        <para>
          Скрипт <filename>django-admin.py</filename> должен быть в
          вашем системном пути, если вы устанавливали Django с помощью
          утилиты <filename>setup.py</filename>.
        </para>

        <para>
          Если же вы используете код из ствола, то он должен быть в
          каталоге <filename>djtrunk/django/bin</filename>. Так как вы
          часто будете использовать скрипт
          <filename>django-admin.py</filename>, рассмотрите его
          добавление в системный путь. На Unix вы можете
          воспользоваться символической ссылкой, например:
          <screen>
sudo ln -s /path/to/django/bin/django-admin.py \
           /usr/local/bin/django-admin.py
          </screen>
          На Windows вам потребуется внести изменение в переменную
          среды <varname>PATH</varname>.
        </para>

        <para>
          Если вы установили Django из пакета вашего дистрибутива
          Linux, то <filename>django-admin.py</filename> может
          называться просто <filename>django-admin</filename>.
        </para>
      </note>
    </para>

    <para>
      Если вы увидите сообщение <quote>permission denied<footnote
      id="startproject.fn01"><para>Доступ запрещён.</para></footnote>
      </quote> при запуске <command>django-admin.py
      startproject</command>, вам потребуется изменить права доступа к
      файлу. Чтобы сделать это перейдите в каталог где установлен файл
      <filename>django-admin.py</filename> (например, в
      <filename>/usr/local/bin</filename>) и выполните команду
      <command>chmod +x django-admin.py</command>.
    </para>

    <para>
      Посмотрим на результаты работы команды:
      <screen>
mysite/
    __init__.py
    manage.py
    settings.py
    urls.py
      </screen>
    </para>

    <para>
      Опишем назначение каждого файла:
      <itemizedlist>
        <listitem>
          <para>
            <filename>__init__.py</filename>: Файл необходим для того,
            чтобы Python рассматривал данный каталог как пакет, т.е.,
            как группу модулей. Это пустой файл и обычно вам не
            требуется добавлять что-либо в него.
          </para>
        </listitem>

        <listitem>
          <para>
            <filename>manage.py</filename>: Это утилита командной
            строки, которая позволяет вам взаимодействовать с проектом
            различными методами. Наберите <command>python manage.py
            help</command> для получения информации о возможностях
            утилиты. Вы не должны изменять содержимое данного файла,
            он создан в данном каталоге в целях удобства.
          </para>
        </listitem>

        <listitem>
          <para>
            <filename>settings.py</filename>: Настройки для текущего
            проекта Django. Посмотрите на содержимое файла, чтобы
            иметь представление о типах доступных параметров и их
            значениях по умолчанию.
          </para>
        </listitem>

        <listitem>
          <para>
            <filename>urls.py</filename>: Описания URL для текущего
            проекта Django, так сказать <quote>оглавление</quote> для
            вашего сайта. На момент создания должен быть пустым
            (FIXME: по-моему авторы гонят.)
          </para>
        </listitem>
      </itemizedlist>
    </para>

    <para>
      Несмотря на свой небольшой размер, эти файлы формируют
      работоспособное приложение Django.
    </para>

    <section id="&BASEID;.running-devserver">

      <title id="&BASEID;.running-devserver.title">
        Запуск сервера разработки
      </title>

      <para>
        Для проверки правильности установки Django давайте запустим
        сервер разработки, чтобы посмотреть на наше приложение в
        действии.
      </para>

      <para>
        Сервер разработки Django (также называемый
        <quote>runserver</quote>, по имени команды, которая его
        запускает) &mdash; это встроенный лёгкий веб сервер, который
        вы можете использовать в процессе разработки вашего сайта. Он
        включен в Django для того, чтобы вы могли быстро приступить к
        разработке вашего сайта без траты времени на конфигурирование
        вашего боевого веб сервера (т.е., Apache) раньше времени. Этот
        сервер разработки отслеживает изменения в вашем коде и
        автоматически перезагружает его, помогая видеть вносимые вами
        изменения без перезагрузки веб сервера.
      </para>

      <para>
        Для запуска сервера перейдите в каталог
        <filename>mysite</filename> (<command>cd mysite</command>),
        если вы ещё не сделали этого, и выполните команду:
        <screen>
python manage.py runserver
        </screen>
      </para>

      <para>
        Вы увидите нечто подобное этому:
        <screen>
Validating models...
0 errors found.

Django version 1.0, using settings 'mysite.settings'
Development server is running at http://127.0.0.1:8000/
Quit the server with CONTROL-C.
        </screen>
      </para>

      <para>
        Команда запускает сервер локально на порту 8000. Сервер
        принимает только локальные соединения с вашего
        компьютера. Теперь он запущен, посетите страницу
        <token>http://127.0.0.1:8000/</token> с помощью браузера. Вы
        увидите страницу <quote>Welcome to Django<footnote
        id="running-devserver.fn01"><para>Добро пожаловать в
        Django.</para></footnote></quote>. Всё работает!
      </para>

      <para>
        Ещё об одном обязательно надо сказать.  Несмотря на то, что
        сервер разработки очень удобен во время разработки,
        сопротивляйтесь искушению использовать этот сервер в боевом
        режиме. Этот сервер может обрабатывать только один запрос в
        единицу времени и он не проходил никакого аудита на предмет
        безопасности. Когда придёт время поднять ваш сайт, обратитесь
        к главе <quote><xref linkend="djangobook.chap20"
        endterm="djangobook.chap20.title"/></quote> для информации о
        том, как установить туда проект Django.
      </para>

      <para>
        <note>
          <title>
            Как изменить адрес и порт на котором работает сервер
          </title>

          <para>
            По умолчанию, команда <command>runserver</command>
            запускает сервер разработки на порту 8000, принимая только
            локальные соединения. Если требуется изменить порт, его
            можно указать в аргументах командной строки:
            <screen>
python manage.py runserver 8000
            </screen>
            Указав IP адрес, вы разрешаете веб серверу обрабатывать
            внешние подключения. Это особенно полезно, если требуется
            разделить разрабатываемый сайт с другими членами
            команды. IP адрес <token>0.0.0.0</token> указывает серверу
            принимать подключения со всех имеющихся сетевых
            интерфейсов:
            <screen>
python manage.py runserver 0.0.0.0:8000
            </screen>
          </para>

          <para>
            Когда вы сделаете это, другие компьютеры в вашей локальной
            сети смогут получить доступ к вашему сайту на Django по IP
            адресу его компьютера, например,
            <token>http://192.168.1.103:8000/</token>. Следует
            отметить, что вам потребуется посмотреть свои сетевые
            настройки для определения вашего IP адреса в локальной
            сети. Пользователи Unix могут воспользоваться утилитой
            <command>ifconfig</command>. Пользователи Windows &mdash;
            утилитой <command>ipconfig</command>.
          </para>
        </note>
      </para>

      <para>
        После запуска сервера, посетите <ulink
        url="http://127.0.0.1:8000/"/> с помощью вашего веб
        браузера. Вы увидите страницу <quote>Welcome to
        Django</quote>. Оно работает!
      </para>

    </section>

  </section>

  <section id="&BASEID;.debugging">

    <title id="&BASEID;.debugging.title">
      Отладка
    </title>

    <para>
      По материалам сайта <ulink
      url="http://simonwillison.net/2008/May/22/debugging/"/>.
    </para>

    <para>
      Стандартная страница ошибки Django &mdash; великолепна. Она
      предоставляет детальную трассировку, предоставляя локальные
      переменные, позволяет вам разворачивать строки кода вокруг
      строки с ошибкой, предоставляет текстовое описание исключения,
      удобное для отправки по почте коллегам и даже возможность
      отправить одной кнопкой детали ошибки на <ulink
      url="http://dpaste.com/"/>, чтобы вы могли обсудить её на IRC
      канале. Страница предоставляет информацию о настройках
      приложения, о содержимом переменных запроса <token>GET</token>,
      <token>POST</token> и <token>COOKIE</token> и о всех
      значительных полях <token>META</token> собранных из среды HTTP
      сервера (отличный метод вспомнить, как правильно писать
      <token>HTTP_REFERER</token>).
    </para>

    <para>
      Первым полезным советом будет то, что вы можете всегда вызвать
      отображение страницы с ошибкой при обработке любого
      представления, просто добавив строку:
      <screen>
        <![CDATA[
assert False
        ]]>
      </screen>
    </para>

    <para>
      Вы можете указать выражение, которое будет отображено в начале
      страницы:
      <screen>
        <![CDATA[
assert False, request.GET
        ]]>
      </screen>
    </para>

    <para>
      Одним из стандартных мест для использования такого подхода
      является сложная форма. Если вам требуется увидеть данные,
      которые были переданы пользователем, вставьте <command>assert
      False</command> в представление, на которое указывает форма и
      используйте полученную страницу с ошибкой для исследования
      данных.
    </para>

    <section id="&BASEID;.debugging.console">

      <title id="&BASEID;.debugging.console.title">
        Журналирование на консоль сервера разработки
      </title>

      <para>
        Если необходимо иметь информацию о том, что происходит при
        выполнении функции представления, самым быстрым способом будет
        поместить в представление оператор
        <token>print</token>. Сервер разработки выводит результат
        обработки оператора <token>print</token> напрямую на
        терминал. Это альтернатива со стороны сервера JavaScript
        функции <function>alert()</function>.
      </para>

      <para>
        Если требуется более сложный подход к журналированию, лучше
        использовать соответствующий модуль языка Python, который
        является частью стандартной библиотеки. Вы можете настроить
        его в файле настроек проекта &mdash;
        <filename>settings.py</filename>:
        <screen>
          <![CDATA[
import logging
logging.basicConfig(
    level = logging.DEBUG,
    format = '%(asctime)s %(levelname)s %(message)s',
)
          ]]>
        </screen>
        Для 1.3 смотрите <ulink url="https://docs.djangoproject.com/en/1.3/topics/logging/"/>
      </para>

      <para>
        Затем можно осуществлять журналирование из любой функции
        представления:
        <screen>
          <![CDATA[
def my_view(request):
    import logging
    logging.debug("A log message")
    ...
          ]]>
        </screen>
      </para>

      <para>
        И снова, этот метод приведёт к выводу отладочных сообщений на
        терминал сервера разработки. Если требуется выводить сообщения
        в файл, вы можете это реализовать, немного усовершенствовав
        метод:
        <screen>
          <![CDATA[
logging.basicConfig(
    level = logging.DEBUG,
    format = '%(asctime)s %(levelname)s %(message)s',
    filename = '/tmp/myapp.log',
    filemode = 'w'
)
          ]]>
        </screen>
      </para>

      <para>
        После этого вы можете использовать <command>tail -f
        /tmp/myapp.log</command> для отслеживания отладочной
        информации в реальном времени. Этот способ может
        использоваться как во время отладки приложения, так и в боевом
        режиме.
      </para>

      <para>
        Всё описанное выше лишь слегка затрагивает возможности
        стандартного модуля журналирования языка Python. Если немного
        <ulink
        url="http://docs.python.org/lib/module-logging.html">покопаться
        в документации</ulink>, вы сможете использовать этот модуль
        для ротации журнальных файлов, для отправки сообщений по сети
        и даже отправлять их методом <token>POST</token> на сторонний
        веб-сервер.
      </para>

      <para>
        Довольно часто приходится иметь дело с ошибкой, которая
        проявляется только в определённых ситуациях, ведь функция
        может вызываться из дюжины различных мест вашей программы, но
        ошибка происходит только в одном, очень особом, случае. Вы
        можете использовать <ulink
        url="http://docs.python.org/lib/module-traceback.html">модуль
        трассировки</ulink> для сохранения состояния стека, это
        позволит вам понять как была вызвана проблемная функция:
        <screen>
          <![CDATA[
import logging, traceback, pprint

def my_buggy_function(arg):
    ...
    if error_condition:
        stack = pprint.pformat(traceback.extract_stack())
        logging.debug('An error occurred: %s' % stack)
          ]]>
        </screen>
      </para>

      <para>
        Кортеж, полученный в результате выполнения
        <function>traceback.extract_stack()</function>, включает в
        себя номера строк, имена функций и пути к файлам Python,
        т.е. вы можете реконструировать достаточный объём информации о
        работе своей программы.
      </para>

    </section>

    <section id="&BASEID;.debugging.debugger">

      <title id="&BASEID;.debugging.debugger.title">
        Использование отладчика
      </title>

      <para>
        Наиболее мощным оружием в процессе отладки является
        соответствующий отладчик &mdash; <ulink
        url="http://docs.python.org/lib/module-pdb.html">pdb</ulink>. Он
        поставляется в стандартной библиотеке языка Python и является
        отладчиком командной строки. Существует множество способов
        активации отладчика, но наиболее прямым способом является
        добавление нижеприведённой строки в функцию представления:
        <screen>
          <![CDATA[
import pdb; pdb.set_trace()
	  ]]>
        </screen>
      </para>

      <para>
        При посещении соответствующей страницы браузером, последний
        <quote>подвиснет</quote> &mdash; будет казаться, что страница
        загружается крайне медленно. На самом деле сервер разработки
        прекратит выполнение функции представления и передаст
        управление отладчику, вы получаете к нему доступ на консоли и
        можете взаимодействовать с кодом представления.
      </para>

      <para>
        Я упомянул, что вы никогда, ещё раз, никогда не должны
        оставлять эту строчку при установке проекта на боевой сервер?
      </para>

      <para>
        Таким образом, вы получили подвисший сервер разработки и
        приглашение отладчика на консоли. Что же со всем этим делать?
        Да всё, что угодно. Сначала следовало бы <ulink
        url="http://www.onlamp.com/pub/a/python/2005/09/01/debugger.html">почитать
        документацию</ulink> на отладчик, но далее приведены несколько
        полезных команд:
        <itemizedlist>
          <listitem>
            <para>
              <command>list</command> &mdash; Отображает строки
              исходного кода вокруг текущей точки выполнения. Вы
              можете выполнять эту команду многократно для увеличения
              объёма отображаемого кода.
            </para>
          </listitem>

          <listitem>
            <para>
              <command>n</command> &mdash; Выполняет следующую строку.
            </para>
          </listitem>

          <listitem>
            <para>
              <command>s</command> &mdash; Аналогично предыдущей
              команде, но заходит в любую вызываемую функцию.
            </para>
          </listitem>

          <listitem>
            <para>
              <command>r</command> &mdash; Выполняет текущую функцию до
              конца.
            </para>
          </listitem>

          <listitem>
            <para>
              <command>u</command> &mdash; Переходит на один уровень
              вверх по стеку, т.е., можно перейти в родительскую
              функцию.
            </para>
          </listitem>

          <listitem>
            <para>
              <command>locals()</command> &mdash; Это не команда
              отладчика, но очень полезна для получения текущей
              области видимости.
            </para>
          </listitem>
        </itemizedlist>
      </para>

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

      <para>
        Но следует помнить, что всё это время браузер будет пытаться
        получить страницу. Если вы нажмёте <command>c</command>, то
        ваше приложение продолжит работу, запрос будет обработан и ваш
        браузер вздохнёт с облегчением.
      </para>

      <para>
        К счастью, нет необходимости в <quote>замораживании</quote>
        сервера разработки во время работы с отладчиком. Отладчик
        отлично работает в интерактивной оболочке Django. Просто
        запустите проблемную функцию и затем делайте так:
        <screen>
          <![CDATA[
>>> def function_that_raises_an_exception():
...   assert False
...
>>> function_that_raises_an_exception()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in function_that_raises_an_exception
AssertionError
>>> import pdb; pdb.pm()
> <stdin>(2)function_that_raises_an_exception()
(Pdb)
          ]]>
        </screen>
      </para>

      <para>
        Метод <function>pdb.pm()</function> позволяет вам вернуться
        для отладки самого последнего исключения, даже если вы ещё не
        произвели импорт модуля отладчика на время вызова исключения.
      </para>

      <para>
        И последний совет по использованию отладчика: вы можете
        использовать его для отладки скриптов командной строки,
        подобных <filename>./manage.py</filename>. Запустите его так:
        <screen>
          <![CDATA[
python -i manage.py buggy_command
          ]]>
        </screen>
      </para>

      <para>
        Аргумент <token>-i</token> указывает интерпретатору, что надо
        перейти в интерактивный режим после запуска скрипта. Если
        скрипт вызывает исключение, вы можете использовать метод
        <function>pdb.pm()</function> для отладки.
      </para>

    </section>

    <section id="&BASEID;.debugging.production">

      <title id="&BASEID;.debugging.production.title">
        Обработка ошибок в <quote>боевом</quote> режиме
      </title>

      <para>
        Стандартным поведением Django в <quote>боевом</quote> режиме
        (т.е., когда параметр <token>DEBUG</token> установлен в
        <token>False</token>) является отправка на почту отчёта о
        вызванном исключении всем, кто перечислен в секции
        <token>ADMINS</token>. Также можно включить отправку отчётов
        на каждую ошибку 404 с помощью параметра
        <token>SEND_BROKEN_LINK_EMAILS</token>, отправка будет
        осуществлена всем, кто перечислен в секции
        <token>MANAGERS</token>. Больше эти настройки ничего не делают
        &mdash; это древний кусочек Django.
      </para>

      <para>
        При работе сайта под высокой нагрузкой, вероятно, вам
        пригодится решение <ulink
        url="http://code.google.com/p/django-db-log/">django-db-log</ulink>
        от Дэвида Крамера (David Cramer), которое записывает
        исключения в таблицу базы данных. Оно по-хитрому использует
        MD5 хэш от трассировки для объединения множества сообщений об
        одной ошибке. Так же оно является отличным примером того, как
        использовать обработчик <token>process_exception</token>
        Django для своих целей.
      </para>

    </section>

    <section id="&BASEID;.debugging.middleware">

      <title id="&BASEID;.debugging.middleware.title">
        Ещё о полезном ПО
      </title>

      <para>
        <itemizedlist>
          <listitem>
            <para>
              <ulink
              url="http://www.djangosnippets.org/snippets/727/">ProfilerMiddleware</ulink>
              &mdash; позволяет получить вывод <ulink
              url="http://docs.python.org/lib/module-profile.html">модуля
              cProfile</ulink> для конкретного URL, если добавить к
              нему <token>?prof</token>.
            </para>
          </listitem>

          <listitem>
            <para>
              <ulink
              url="http://www.djangosnippets.org/snippets/766/">DebugFooter</ulink>
              &mdash; добавляет снизу страницы информацию о
              загруженных шаблонах и о выполненных SQL запросах.
            </para>
          </listitem>
        </itemizedlist>
      </para>

    </section>

    <section id="&BASEID;.debugging.test-client">

      <title id="&BASEID;.debugging.test-client.title">
        Тестовый клиент
      </title>

      <para>
        Завершим этот раздел по интерактивному исследованию вашего
        приложения советом изучить использование <ulink
        url="http://www.djangoproject.com/documentation/testing/">TestClient</ulink>. Несмотря
        на то, что он был разработан для юнит-тестов Django, он
        подойдёт и для нашей цели. Этот инструмент позволяет
        имитировать запрос к вашему приложению из вашего кода. Пример:
        <screen>
          <![CDATA[
>>> from django.test.client import Client
>>> c = Client()
>>> response = c.get("/") # The homepage
>>> response
<django.http.HttpResponse object at 0x2300470>
>>> print response
Vary: Cookie
Content-Type: text/html; charset=utf-8

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
    "http://www.w3.org/TR/html4/strict.dtd">
<html>
...
          ]]>
        </screen>
      </para>

      <para>
        В ответ вы получите объект
        <classname>HttpResponse</classname>, который можно
        интерактивно исследовать.
      </para>

      <para>
        Существует ещё одна функция, которая может помочь в
        интерактивной отладке приложения &mdash;
        <function>setup_test_environment()</function>. Пример:
        <screen>
          <![CDATA[
>>> from django.test.utils import setup_test_environment
>>> setup_test_environment()
>>> from django.test.client import Client
>>> c = Client()
>>> response = c.get("/")
>>> response.template
[<django.template.Template object at 0x2723dd0>,
 <django.template.Template object at 0x2723f30>,
 <django.template.Template object at 0x273ee10>]
>>> response.context
[ list of Context objects ]
          ]]>
        </screen>
      </para>

      <para>
        Это позволяет вам исследовать не только HTML, возвращённый
        функцией представления, но также шаблоны и контексты, которые
        были использованы для его рендеринга.
      </para>

    </section>

  </section>

  <section id="&BASEID;.faststart">

    <title id="&BASEID;.faststart.title">
      Быстрый старт
    </title>

    <para>
      Каждый проект начинается с создания каталога:
      <screen>
        <![CDATA[
django-admin.py startproject megaproject
        ]]>
      </screen>
    </para>

    <para>
      Планируется, что проект должен работать с базой
      данных. Подразумевается, что база данных уже создана в
      соответствии с разделом <quote><xref
      linkend="djangobook.chap05.dbconfig"
      endterm="djangobook.chap05.dbconfig.title"/></quote>. Для работы
      с базой данных необходимо создать в проекте приложение, причины
      этого описаны в разделе <quote><xref
      linkend="djangobook.chap05.firstapp"
      endterm="djangobook.chap05.firstapp.title"/></quote>. Переходим
      в каталог <filename>./megaproject</filename> и приступаем к
      созданию:
      <screen>
        <![CDATA[
python manage.py startapp gigaapp
        ]]>
      </screen>
    </para>

    <para>
      Переходим в каталог <filename>./gigaapp</filename> и принимаемся
      за наполнение файла <filename>models.py</filename>, в
      соответствии с разделом <quote><xref
      linkend="djangobook.chap05.firstmodel"
      endterm="djangobook.chap05.firstmodel.title"/></quote>.
    </para>

  </section>

</chapter>