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

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

Как всегда пример:

#!/usr/bin/perl -w

use threads;
use threads::shared;

# Объявляем переменную общей для всех нитей с
# помощью модификатора shared
my $i : shared = 1;

# Альтернативный способ - использование функции share
my $j = 0;
share $j;

threads->new(\&my_sub)->join();
threads->new(\&my_sub)->join();
threads->new(\&my_sub)->join();

sub my_sub()
{
    print "Это вызов #$i. Переменная \$j = $j\n";
    $j++;
    $i++;
}

Результат такого скрипта в консоли выглядит примерно так:

% perl threads.pl
Это вызов #1. Переменная $j = 0
Это вызов #2. Переменная $j = 1
Это вызов #3. Переменная $j = 2

Вроде бы всё понятно и просто и пора уже с многопоточностью заканчивать. В качестве прощания мы с вами напишем скрипт, который будет выдирать прокси с первых пяти страниц небезызвестного ресурса MPR Proxylist (разумеется, каждая страница отдельным потоком ). В качестве HTTP-клиента используется библиотека LWP, которая обычно установлена (если не установлена, то пользователи FreeBSD могут устанавливать порт www/p5-libwww, а линуксоидам ничем помочь не могу ):

#!/usr/bin/perl -w

use LWP::UserAgent;
use threads;
use threads::shared;

# В этом массиве будут храниться найденные прокси
my @proxies : shared;

# Массив для хранения ссылок на объекты нитей
my @threads;

# Количество страниц (и, разумеется,  нитей  )
my $threads = 5;

# Создаём $threads нитей, каждая из которых будет
for (my $i = 0; $i < $threads; $i++) {
    threads->new(\&find_proxy, $i);
}

# Скрипт будет жить до завершения работы всех нитей
foreach my $thread (@threads) {
    $thread->join();
}

# Записываем найденные прокси в файл
open PROXIES, '>', 'proxylist.txt';

foreach my $proxy (@proxies) {
    print PROXIES $proxy, "\n";
}

close PROXIES;

# Создание HTTP-клиента на основе LWP (при кажом создании
# у клиента будет разные User-Agent
sub http_factory()
{
    my @agents = ('Mozilla 5.0/Firefox',
                  'Opera 9.02',
                  'Interner Explorer 7',
                  'Safari 3.0/Gecko 31337',
                  'Lynx/FreeBSD 6.0');
    my $client = LWP::UserAgent->new('agent' => $agents[rand($#agents)]);
    return $client;
}

# Процедура соединения с донором и парсинг прокси
sub find_proxy
{
    my $page = shift;
    my $url = sprintf('http://proxylist.sakura.ne.jp/index.htm?pages=%s', $page);
    my $client = &http_factory();
    my $response = $client->get($url) or warn "Can't connect $url: $@\n";

    if ($response->is_success() && $response->content_type() eq 'text/html') {
        my $content = $response->content();

        while ($content =~ m!
(.*?)

\s*?
([a-z]{2})

!sgi) {
            my $proxy = $1;
            my $country = $2;
            push @proxies, $proxy;
            print "Found $proxy [$country], saving it\n";
        }
    }

    else {
        print "fuck! $@\n";
    }
}

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

Удачного дня

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

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

С места в карьер

Теперь собственно о том, как программировать разделение на нити. Начну сразу с примера:

#!/usr/bin/perl -w
use threads;

# Создаем три параллельных нити
threads->new(\&get_now, 'number one');
threads->new(\&get_now, 'number two');
threads->new(\&get_now, 'number three');

sub get_now
{
    my $arg = shift;
    print "Thread ", $arg, ": time = ", time(), "\n";
    sleep 1;
}

Пробежимся по коду:

1. Директива use threads подключает объектно-ориентированную обёртку для работы с нитями (далее будем использовать это слово) приложения. В общем, с этим всё ясно.
2. Далее идёт собственно деление основной программы на потоки. В нашем примере создаётся 3 нитки, в каждой из которых мы вызываем процедуру get_now(), которая, как Вы догадались, выводит некоторую строку, текущий UNIX TIMESTAMP и ложится спать на 1 секунду.

Запустив код, Вы увидите примерно следующее:
%perl threads.pl
Thread number one: time = 1194392538
Thread number two: time = 1194392538
A thread exited while 4 threads were running.

Как видите, таймштампы одинаковые, из чего можно заключить, что вторая нить запустилась, не дожидаясь окончания работы первой, которая, в свою очередь, «засыпает» на одну секунду (собственно, sleep в get_now() был поставлен именно для того, чтобы нить выполнялась некоторое ощутимое время). Однако у нас не всё благополучно: вместо выхода третьей ветки появилось какое-то странное сообщение. Его природу рассмотрим чуть ниже, а пока порадуемся полчаса: многопоточность работает .

О начальниках и подчинённых

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

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

Теперь вернёмся к сообщению об ошибке из предыдущего раздела:

A thread exited while 4 threads were running.

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

#!/usr/bin/perl -w
use threads;

# Создаем три параллельных нити
threads->new(\&get_now, 'number one');
threads->new(\&get_now, 'number two');
threads->new(\&get_now, 'number three');

sleep 2;
print "Патрон ушёл домой\n";

sub get_now
{
    my $arg = shift;
    print "Thread ", $arg, ": time = ", time(), "\n";
    sleep 1;
}

Теперь результат работы скрипта будет таким:

%perl threads.pl
Thread number one: time = 1194394574
Thread number two: time = 1194394574
Thread number three: time = 1194394574
Патрон ушёл домой

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

Из этого всего можно сделать вывод, что Perl по умолчанию ведёт себя ведёт как начальник-халтурщик. Нас это, разумеется, не устраивает, поэтому я продолжаю читать мануал вслух . Оказывается, наш начальник может быть многоликим, как небезызвестный Анус Янус: строгим или добрее дедушки Ленина. А может вообще к каждому подчинённому относиться по-своему.

Если без метафор, то это означает следующее: при создании потока, можно указать интерпретатору Perl, ожидать ли завершение работы ветки или создать и забыть. Реализация поведения проста: достаточно при создании нити вызвать метод join() для ожидания завершения работы или же dettach() для отказа управления

Сразу приведу примеры: вот так выглядит вызов метода join() каждой нити:

#!/usr/bin/perl -w
use threads;

# Создаем три параллельных нити
threads->new(\&get_now, 'number one')->join();
threads->new(\&get_now, 'number two')->join();
threads->new(\&get_now, 'number three')->join();

sub get_now
{
    my $arg = shift;
    print "Thread ", $arg, ": time = ", time(), "\n";
    sleep 1;
}

Результат обескураживает:

% perl threads.pl
Thread number one: time = 1194395930
Thread number two: time = 1194395931
Thread number three: time = 1194395932

Вдумчивый читатель обязательно задаст вопрос: «А где же здесь многопоточность?». И будет абсолютно прав, потому что в данном примере многопоточности как таковой нет. Но ещё не вечер, читайте далее, наша цель — расставить все точки над «ё» .

А вот пример вызова dettach() при создании нити:

#!/usr/bin/perl -w
use threads;

# Создаем три параллельных нити
threads->new(\&get_now, 'number one')->dettach();
threads->new(\&get_now, 'number two')->dettach();
threads->new(\&get_now, 'number three')->dettach();

sub get_now
{
    my $arg = shift;
    print "Thread ", $arg, ": time = ", time(), "\n";
    sleep 1;
}

Как это выглядит в консоли:

%perl threads.pl
Thread number one: time = 1194396131
A thread exited while 2 threads were running.

В общем, как и ожидалось, основная программа отработала раньше нитей.

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

Ход конём

Решение напрашивается само собой: сначала нужно создать требуемое количество нитей, а потом, уже после их запуска, у каждой из них вызывать метод join(). Как это реализовать? Ход конём — сохраним объекты нитей в массиве (комментарии будут прямо в коде):

#!/usr/bin/perl -w
use threads;

# В этом массиве будут храниться ссылки на
# созданные нити
my @threads;

# Создаём 3 нити в режиме по прниципу "создал и забыл", тем
# самым позволив открыть  параллельно несколько нитей. Объект
# каждой созданной нити помещается в массив @threads
for my $i (1..3) {
  push @threads, threads->create(\&get_now, $i);
}

# Нити успешно созданы,  ссылки на объекты помещены в массив
# Теперь мы можем для каждого объекта вызвать метод join(),
# заставляющий интерпретатор ожидать завершение работы треда.

foreach my $thread (@threads) {
    # Обратите внимание, что $thread является не объектом, а ссылкой,
    # поэтому управление ему передано не будет.
    $thread->join();
}

sub get_now
{
    my $num = shift;
    print "thread ", $num, " => ", time(), "\n";
    sleep 1;
}

Вот теперь всё работает так, как и ожидалось.

% perl threads.pl
thread 1 => 1194388015
thread 2 => 1194387015
thread 3 => 1194387015

Вот теперь, как видите, всё работает как надо .

To be continued…

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

С многопоточностью в моем понимании в PERL дела обстоят куда лучше, чем в PHP: возможность поддержки нитей заложена в ядре языка (хотя по умолчанию многопоточность выключена) начиная с версии 5.6, а в стандартном наборе пакетов имеется объектно-ориентированный модуль, позволяющий легко и просто манипулировать потоками.

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

Для управления потоками в стандартный состав Perl входит модуль threads.pm. Но если Perl собран без поддержки многопоточности (а по умолчанию это именно так), работать этот не будет. Поэтому самый простой способ проверки, поддерживается многопоточночть или нет — запуск из консоли пустого скрипта с подключением модуля threads:

$ perl -e 'use threads'
$ 

Если ничего не произошло, то модуль threads отработал как надо, сладовательно, Perl собран с поддержкой нитей. А если в терминале наблюдается что-то вроде такого:

$ perl -e 'use threads'
-e line 1:

This Perl hasn't been configured and built properly for the threads
module to work.  (The 'useithreads' configuration option hasn't been used.)

Having threads support requires all of Perl and all of the XS modules in
the Perl installation to be rebuilt, it is not just a question of adding
the threads module.  (In other words, threaded and non-threaded Perls
are binary incompatible.)

If you want to the use the threads module, please contact the people
who built your Perl.

Cannot continue, aborting.
BEGIN failed--compilation aborted at /usr/local/lib/perl5/5.8.8/mach/threads.pm line 28.
Compilation failed in require at -e line 1.
BEGIN failed--compilation aborted at -e line 1.

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

Обращаю внимание вот на этот фрагмент сообщения:

Having threads support requires all of Perl and all of the XS modules in
the Perl installation to be rebuilt, it is not just a question of adding
the threads module. (In other words, threaded and non-threaded Perls
are binary incompatible.)

Забегая вперед, скажу, что у меня после пересборки Perl перестал работать HTML::Parser, используемый пакетом LWP. Переустановка, разумеется, помогла .

Perl, как и всё в FreeBSD, мы будем переустанавливать из портов (для порядка сошлюсь на мануал, хотя ты, достопочтимый читатель, наверняка это всё отлично знаешь).

$ su
# cd /usr/ports/lang/perl5.8
# make FORCE_PKG_REGISTER=1 WITH_THREADS=yes reinstall clean

Небольшие пояснения (опять же, чтобы объяснение было полным, я не сомневаюсь, что все умеют работать с портами) о том, что же мы сделали этими командами:

• Первая строка позволяет получить root-права. Разумеется, текущий пользователь должен входить в группу wheel и знать root-пароль

  Обратите внимание, что после получения root-привилегий приглашение в консоли изменилось. Чаще всего так и бывает

• Второй строкой мы переходим в каталог порта Perl 5.8.
• Третья строка запускает процесс переустановки perl с ключом usethreads (список всех параметров можно прочитать в Makefile порта). Параметр FORCE_PKG_REGISTER позволит переустановить программу, не удаляя ее из реестра установленных пакетов.

Процесс пересборки довольно быстрый: на Celeron-1.7/512Mb он занял что-то около 5 минут (специально засечь не догадался. Если интересно — man time ).

Когда сборка удачно завершится, ваш Perl станет многопоточным. Однако прежде чем начать программирование, желательно переустановить несколько пакетов. Как я уже говорил, у меня отказался работать HTML::Parser, который активно юзается веб-клиентом LWP. Других проблем пока не обнаружил.

Зная имя пакета, можно найти его порт и переустановить. Вот правила, по которым строится имя перлового модуля в дереве портов FreeBSD (опять же на примере HTML::Parser): названеие начинается на p5-, далее идёт название пакета (c учётом регистра), в котором двойное двоеточие (оно означает ссылку на пространство имён) заменяются дефисом. То есть пакет HTML::Parser в дереве портов FreeBSD называется p5-HTML-Parser.

# cd /usr/ports
# make search name=p5-HTML-Parser

Port:   p5-HTML-Parser-3.56
Path:   /usr/ports/www/p5-HTML-Parser
Info:   Perl5 module for parsing HTML documents
Maint:  perl@FreeBSD.org
B-deps: p5-HTML-Tagset-3.10 p5-Test-Harness-2.64 p5-Test-Simple-0.70 p5-URI-1.35 perl-5.8.8
R-deps: p5-HTML-Tagset-3.10 p5-URI-1.35 perl-5.8.8
WWW:    http://search.cpan.org/dist/HTML-Parser/

# cd /usr/ports/www/p5-HTML-Parser
# make FORCE_PKG_REGISTER reinstall clean

Делается это всё, разумеется, с правами суперпользователя. Вот теперь можно приступать к программированию

To be continued…

Собственно, эта тема обсасывалась уже уже не раз и не два (призываю Google в свидетели), поэтому не буду разводить тряхомудиюдемагогию, а сразу приведу исходник класса, который позволяет довольно просто выполнять несколько HTTP-запросов параллельно:

class HttpQueue
{
    /**
     * An array of URLs
     *
     * @access  private
     * @var     array
     */
    private $_urls = array(); 

    /**
     * An array of server sockets
     *
     * @access  private
     * @var     array
     */
    private $_sockets = array(); 

    /**
     * An array of server responses
     *
     * @access  private
     * @var     array
     */
    private $_response = array(); 

    /**
     * Socket timeout
     *
     * @access  private
     * @var     integer
     */
    private $_timeout = 30; 

    /**
     * An array of sockets which can be received
     *
     * @access  private
     * @var     array
     */
    private $_read = array(); 

    /**
     * An array of sockets which can be sended
     *
     * @access  private
     * @var     array
     */
    private $_write = array(); 

    /**
     * Adds an URL into a tasklist
     *
     * @access  public
     * @param   string  $method
     * @param   string  $url
     * @return  void
     */
    public function add($method, $url)
    {
        $this->_urls[] = array(strtoupper($method), $this->_parseUrl($url));
    } 

    /**
     * Parses requested URL and checks for all URL parts
     *
     * @access  private
     * @param   string   $url
     * @return  array
     */
    private function _parseUrl($url)
    {
        $parts = parse_url($url);
        $parts['port'] = array_key_exists('port', $parts) ? $parts['port'] : 80;
        $parts['sock'] = sprintf('%s:%s', $parts['host'], $parts['port']);
        $parts['request'] = sprintf('%s?%s', $parts['path'], $parts['query']);
        return $parts;
    } 

    /**
     * Starts fetch process
     *
     * @access  public
     * @param   void
     * @return  array
     */
    public function fetch()
    {
        $this->_create();
        $this->_process();
        return $this->toArray();
    } 

    /**
     * Sets socket timeout (in seconds)
     *
     * @access  public
     * @param   integer  $timeout
     * @return  void
     */
    public function setTimeout($timeout)
    {
        $this->_timeout = $timeout;
    } 

    /**
     * Returns array of server responses
     *
     * @access  public
     * @param   void
     * @return  array
     */
    public function toArray()
    {
        return $this->_response;
    } 

    /**
     * Creates socket conenctions with hosts given in URL
     *
     * @access  private
     * @param   void
     * @return  void
     */
    private function _create()
    {
        foreach ($this->_urls as $id => $connect) {
            if ($socket = @stream_socket_client($connect[1]['sock'], $errno,
                $errstr, $this->_timeout,
                STREAM_CLIENT_ASYNC_CONNECT|STREAM_CLIENT_CONNECT)) {
                $this->_sockets[$id] = $socket;
                $this->_response[$id]  = 'processing';
                continue;
            } 

            $this->_response[$id] = "failed, $errno $errstr";
        }
    } 

    /**
     * Process opened sockets
     *
     * @access  private
     * @param   void
     * @return  void
     */
    private function _process()
    {
        while (count($this->_sockets)) {
            $this->_read  = $this->_sockets;
            $this->_write = $this->_sockets; 

            $select = stream_select($this->_read, $this->_write, $e = null,
                                    $this->_timeout); 

            if ($select > 0) {
                $this->_read();
                $this->_write();
            } 

            else {
                foreach ($this->_sockets as $id => $s) {
                    $this->_response[$id] = 'Timed out';
                } 

                break;
            }
        }
    } 

    /**
     * Receives data from readable socket
     *
     * @access  private
     * @param   void
     * @return  void
     */
    private function _read()
    {
        foreach ($this->_read as $fp) {
            $id = array_search($fp, $this->_sockets);
            $data = fread($fp, 8192); 

            if (strlen($data) == 0) {
                if ($this->_response[$id] == 'processing') {
                    $this->_response[$id] = 'failed to connect';
                } 

                fclose($fp);
                unset($this->_sockets[$id]);
            } 

            else {
                $this->_response[$id].= $data;
            }
        }
    } 

    /**
     * Sends HTTP request into writeable socket
     *
     * @access  private
     * @param   void
     * @return  void
     */
    private function _write()
    {
        foreach ($this->_write as $fp) {
            $id = array_search($fp, $this->_sockets);
            $method  = $this->_urls[$id][0];
            $request = $this->_urls[$id][1]['request'];
            $host    = $this->_urls[$id][1]['host']; 

            fputs($fp, "$method $request HTTP/1.0rn");
            fputs($fp, "Host: $hostrnrn"); 

            $this->_response[$id] = '';
        }
    }
}

Ну и, разумеется, пример использования:

$http = new HttpQueue();
$http->setTimeout(20);
$http->add('get', 'http://ya.ru');
$http->add('get', 'http://google.com');
$http->add('get', 'http://wordpress.com');
$result = $http->fetch();

Чтобы добавить URL в очередь, используется метод HttpQueue::add($method, $url). Первый параметр указывает тип метода передачи данных (в данном классе заработают GET и HEAD; чтобы заработал POST, нужно внести несколько изменений, но это никому не интенесно ), второй — собственно URL.

В результирующем массиве $result будут храниться ответы серверов в том порядке, в котором они были заданы.

P.S. Если я буду продолжать публиковаться, то со временем перестану напоминать, что мои классы работают на PHP4.x и младше

P.P.S. Прошу сильно не пинать ногами за комментарии в DocBlock: по-английски пишу как умею.

1. httpClient – объектно-риентированная обёртка к функциям библиотеки cURL. Простенький и чертовски удобный класс (мне так кажется, по крайней мере .
2. YouTube – непосредственно парсер кода.

Будем считать, что эти классы лежат в файлах httpclient.php и youtube.php соответственно. Тогда скрипт морды будет выглядеть примерно так:

<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
    <title>YouTube DirectLink Extractor</title>
</head>
<body>
<h1>YouTube DirectLink Extractor</h1>
<form method="get">
    <label>Enter Youtube URL:</label>
    &lt;input type="text" name="url" value="<?php echo @$_GET['url'] ?>" size="60" /?
    <button type="submit">Get direct link</button>
</form>
<?php if (isset($_GET['url'])): ?>
<pre>
<?php
include_once 'httpclient.php';
include_once 'youtube.php';

$client = new httpClient();
$client->setProxy('proxy.server.ru', 3128);

$youtube = new YouTube();
$youtube->setHttpClient($client);

/**
 * Execute programme
 *
 */
$result = $youtube->getResult($_GET['url']);

/**
 * Display all results as hash
 *
 */
print_r($result);

/**
 * or output title of url indepently
 *
 */
print 'URL: ' .$youtube->getUrl().'<br />';
print 'Title: '.$youtube->getTitle().'<br />';
?>
</pre>
<?php endif; ?>
</body>
</html>

А вот и исходные коды классов: httpclient.php:

class httpClient
{
    /**
     * Свойство, хранящее дескриптор соединения
     *
     * @var  resource
     */
    private $_curl = null;           

    /**
     * Свойство, сохраняющее ответ сервера на запрос
     *
     * @var  stromg
     */
    private $_response = '';           

   /**
    * Конструктор класса
    *
    * @param   void
    * @return  void
    */           

    public function __construct()
    {
        $this->_curl = curl_init();
        $this->_setOption(CURLOPT_RETURNTRANSFER, true);
    }           

    /**
     * Устанавливает параметры дескриптора CURL
     *
     * @param   integer  $option
     * @param   mixed    $value
     * @return  void
     */
    private function _setOption($option, $value)
    {
        curl_setopt($this->_curl, $option, $value);
    }           

    /**
     * Выполняет HTTP-запрос и возвращает ответ сервера
     *
     * @param   string   $url
     * @param   boolean  $header
     * @return  string
     */
    public function get($url, $header = false)
    {
        $this->_setOption(CURLOPT_URL, $url);
        $this->_setOption(CURLOPT_HEADER, $header);
        return curl_exec($this->_curl);
    }           

    /**
     * Устанавливает адрес и порт прокси]
     *
     * @param   string   $host
     * @param   integer  $port
     * @return  void
     */
    public function setProxy($host, $port = 3128)
    {
        $this->_setOption(CURLOPT_PROXY, $host);
        $this->_setOption(CURLOPT_PROXYPORT, $port);
    }           

    /**
     * Деструктор класса
     *
     * @param   void
     * @return  void
     */
    public function __destruct()
    {
        curl_close($this->_curl);
    }
}

… и youtube.php

class YouTube
{
    /**
     * Свойство, хранящее указатель на объе
     *
     * @var  httpRequest
     */
    private $_httpClient;           

    /**
     * Информация о клипе (по умолчанию пустая  )
     *
     * @var  httpRequest
     */
    private $_result = array('url' => null, 'title' => null);           

    /**
     * Устанавливает используемый HTTP-клиент
     *
     * @param   httpClient   $client
     * @return  void
     */
    public function setHttpClient(httpClient $client)
    {
        $this->_httpClient = $client;
    }           

    /**
     * Выполняет запрос к серверу YouTube и возвращает хеш-массив с
     * полученным данными
     *
     * @param   string  $url
     * @return  array
     */
    public function getResult($url)
    {
        return $this->_parse($url)->_result;
    }           

    /**
     * Непосредственно парсинг UHTML-страничек и вычленение заголовков с
     * перенаправлениями.
     *
     * @param   string  $url
     * @return  YouTube
     */
    private function _parse($url)
    {
        $code = $this->_httpClient->get($url);           

        if (preg_match('/var fs = window.open( "/(.*?)" + "(.*?)" ,/si', $code, $match)) {
            $code = $this->_httpClient->get('http://youtube.com/'.$match[1]);
            $title = $match[2];           

            if (preg_match('/"/player2.swf?(.*)", "player"/si', $code, $match)) {
                $url = 'http://youtube.com/get_video.php?'.$match[1]; // работает
                $code = $this->_httpClient->get($url, true);           

                if (preg_match('/Location:s*?(.*?)n/si', $code, $match)) {
                    $this->_result['url'] = trim($match[1]);
                    $this->_result['title'] = urldecode($title);
                }
            }
        }           

        return $this;
    }           

    /**
     * Возвращает URL видео
     *
     * @param   void
     * @return  string
     */
    public function getUrl()
    {
        return $this->_result['url'];
    }           

    /**
     * Возвращает название видео
     *
     * @param   void
     * @return  string
     */           

    public function getTitle()
    {
        return $this->_result['title'];
    }
}

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

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

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

index.php
youtube.php
httpclient.php

Викторина «Ильф и Петров» на Эхе Москвы

Вы ответили правильно на 15 из 15 вопросов. Иначе говоря, Отлично.

Принять участие в викторине

Вроде бы круто, могу считать себя корифеем . А на самом-то деле… Не
уверен, что авторы этого теста сами удосужились прочитать книжки,
скорее просто ограничились фильмами. Не знаю, на чем основано это
убеждение, но оно имеет место быть .

Особенно первый вопрос порадовал: »Какую Песню напевает Остап
Бендер на протяжении фильма?».  По-моему, с Ильфом и Петровым это
мало связано. И даже о каком фильме идёт речь не указали (лично мне,
кстати, известно 5 экранизаций произведений о похождениях Великого
комбинатора).

В общем, хвастаться особо нечем, как и в тесте на грамотность. Но всё
равно приятно

ты тоже дохера ошибок делаешь

и предложение пройти тест «Российской газеты», в котором моя очаровательная собеседница на тот момент набрала 109 баллов.

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

Должен, однако, сознаться: этот тест я прохожу второй раз. Первый был давным-давно, когда он (этот тест) только-только появился (было это, если мне не изменяет память, в феврале сего года). Тогда результат был чуток поскромнее: 106/116. Но все равно неплохо .

Впрочем, как оказалось, ошибался именно я: подняв на уши кучу знакомых филологов, перерыв кучу справочников, я осознал, что слова «всмысле» как алиаса словосочетания «в смысле» не существует. В чём я прямо тут и расписываюсь   . Придется теперь переучиваться…

Но результаты теста меня все равно порадовали, хоть и спорные там некоторые вопросы.

• Свободное имя… Моё родное имя
• Потому что это модно, глупенькие

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

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

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