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

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

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

• Мы отображаем только погоду только по Москве, хотя сервис у нас глобальный
• Существуют проблемы на разных версиях прошивок для телефонов, которые ожидают данные на русском языке в кодировке cp-1251.

Первый недочет решено было исправить, добавив опциональный параметр city к URL сервиса, равный коду города на сайте ГисМетео, на котором мы берем данные погоды. Таким образом строка для телефонов Питера выглядит как http://xmlphones.appspot.com/?city=26063. Второй аналогично будет называться encode и содержать при необходимости задание кодировки windows-1251.

Перекодировка в Python делается элегантно. Допустим, у нас через URLFetch получены данные в UTF-8, а вывод требуется в windows-1251:

resp = unicode(result.content, 'utf-8')
resp = resp.encode("cp1251")

Ну и наоборот:

resp = unicode(result.content, 'cp1251')

В первом случае мы из байтового массива конструируем объект unicode, который затем кодируем с указанием кодека cp1251. Во втором случае одним действием из байтового массива конструируем также объект unicode с заданием кодека cp1251, но далее просто отдаем его в таком виде платформе App Engine (подразумевается что весь вывод по умолчанию в кодировке UTF-8).

Все кажется замечательным, но тут опять обнаруживается криворукость писателей прошивок некоторых моделей IP телефонов, заключающаяся в том, что телефоны сами добавляют к параметрам запросов дополнительные переменные вида ?locale=English_United_States&name=SEP001B541415EE, что приводит к проблемам обработке меню сами же телефонами.

Проведенный небольшой эксперимент показал, что если, например, параметры задавать с помощью многоуровневых URL, то все работает отлично. Допустим, кодировку windows-1251 мы будем задавать как http://xmlphones.appspot.com/windows-1251/ (подразумевая, по умолчанию корневой адрес аналогичный http://xmlphones.appspot.com/utf-8/), а город как http://xmlphones.appspot.com/utf-8/city/26063 (и опять это Питер).

Выкидываем из кода несколько обработчиков, привязанных к URL, и заменяем их одним Dispatcher, который будет решать куда направить тот или иной запрос. Так как нашим сервисом уже пользуются люди, старые параметры ?encode и ?city также оставляем для совместимости, но делаем их второстепенными по сравнению со схемой параметров, заданных через URL.

Вот что получилось в итоге:

# coding=UTF-8
# -*- coding: utf-8 -*-

import wsgiref.handlers
from google.appengine.ext import webapp
from google.appengine.api import urlfetch
import os
from google.appengine.ext.webapp import template
from xml.dom import minidom
import re
import time

WEATHER_URL = 'http://informer.gismeteo.ru/rss/%s.xml'

def get_city(self):
    city = self.request.get("city")
    if city == '':
        # Москва
        city = '27612'
    ccode = re.search('/.+/meteo/(.+)', self.request.path)
    if ccode != None:
        return ccode.group(1)
    else:
        return city

def get_encode_templ(self):
    encode = self.request.get("encode")
    if encode == 'windows-1251':
        return encode
    else:
        return 'utf-8'

def render_template(self, templ, template_values={}, encode='utf-8'):
    path = os.path.join(os.path.dirname(__file__), 'templates/'+templ)
    resp = template.render(path, template_values)
    if encode == 'windows-1251':
        # Перекодируем из UTF-8 в CP1251
        resp = unicode(resp, 'utf-8')
        resp = resp.encode("cp1251")
    self.response.out.write(resp)

def is_ipphone(self):
    if re.match('Allegro', self.request.headers.get('User-Agent', '')) == None:
        return False
    else:
        return True      

def parse_rss_data(content):
    result = ''
    dom = minidom.parseString(content)
    for item in dom.getElementsByTagName('item'):
        result = result + item.getElementsByTagName('title')[0].firstChild.nodeValue + '\n' + item.getElementsByTagName('description')[0].firstChild.nodeValue + '\n\n'
    return result

def rss_to_text(self, url):
    result = urlfetch.fetch(url)
    if result.status_code == 200:
        resp = parse_rss_data(result.content)
        charset = get_uri_encode(self)
        if charset == 'windows-1251':
            # Перекодируем из UTF-8 в CP1251
            resp = resp.encode("cp1251")
        self.response.headers['Content-type']='text/plain; charset='+charset
        self.response.out.write(resp)
    else:
        self.redirect('/error.xml')

def cbrf(self):
    charset = get_uri_encode(self)
    self.response.headers['Content-type']='text/plain; charset='+charset
    result = urlfetch.fetch('http://www.cbr.ru/currency_base/D_print.asp?date_req='+time.strftime('%d.%m.%Y', time.localtime()))
    if result.status_code == 200:
        content = unicode(result.content, 'windows-1251')
        data=re.split('<td align="right" >036</td>', content)[1]
        for block in re.split('<tr bgcolor="#ffffff">', data):
            block = re.sub('\r\n', '', block)
            cells = re.search('<td align="left" >&nbsp;&nbsp;(.*?)</td><td align="right" >(.*?)</td><td>&nbsp;&nbsp;(.*?)</td><td align="right">(.*?)</td>', block)
            if cells != None:
                resp = cells.group(2)+' '+cells.group(3)+' = '+cells.group(4)+'\n'
                if charset == 'windows-1251':
                    # Перекодируем из UTF-8 в CP1251
                    resp = resp.encode("cp1251")
                self.response.out.write(resp)
    else:
        self.redirect('/error.xml')

def error(self):
    self.response.headers['Content-type]']='text/plain'
    self.response.out.write('Произошла ошибка при работе сервиса')

def gismeteo(self):
    city = get_city(self)
    rss_to_text(self, WEATHER_URL % city)

def yandex_news(self):
    rss_to_text(self, 'http://news.yandex.ru/Russia/index.rss')

def get_uri_encode(self, default = 'utf-8'):
    urcode = re.search('/windows-1251/.*', self.request.url)
    if (urcode != None):
        return 'windows-1251'
    else:
        return default

def main_page(self):
    if is_ipphone(self):
        citytmpl = get_city(self)
        encode = get_encode_templ(self)
        urlcity = re.search('/(.+)/city/(.+)', self.request.path)
        if (urlcity != None):
            citytmpl = urlcity.group(2)
        encode = get_uri_encode(self, encode)
        self.response.headers['Content-type']='text/xml; charset='+encode
        render_template(self, 'main.xml', { 'city': citytmpl, 'encode': encode }, encode=encode)
    else:
        self.response.headers['Content-type']='text/html; charset=utf-8'
        render_template(self, 'main.html')    

class Dispatcher(webapp.RequestHandler):
    def get(self):
        # Анализируем только URI до знака ?
        url = self.request.url.split('?')[0]
        if re.search('/$', url):
            main_page(self)
            return
        if re.search('/.+/city/.+', url):
            main_page(self)
            return
        if re.search('/utf-8/$', url):
            main_page(self)
            return
        if re.search('/windows-1251/$', url):
            main_page(self)
            return
        if re.search('/(.+)/yandex_news.xml', url):
            yandex_news(self)
            return
        if re.search('/(.+)/meteo.+', url):
            gismeteo(self)
            return
        if re.search('/(.+)/cbrf.xml', url):
            cbrf(self)
            return
        error(self)

def main():
    application = webapp.WSGIApplication(
                                         [('/.*', Dispatcher)
                                         ],
                                         debug=True)
    wsgiref.handlers.CGIHandler().run(application)

if __name__ == '__main__':
    main()

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

Начальная настройка

Python уже имеет в своей стандартной поставке модуль unittest, поэтому беспокоиться о его установке не нужно. К сожалению, существуют несколько специфических для App Engine интерфейсов (такие как datastore и users), которые должны быть либо правильно настроены, либо вообще убраны из тестов. Я решил использовать фреймворк mocker и поставить заглушки на специфический код от Google, вместо того, чтобы заниматься созданием самопального хранилища, объектов пользователей и тому подобного. Следующий код определяет пути интерпретатора и импортирует необходимые модули:

import unittest
import sys
import os.path  

# Измените следующую строку для указания актуального пути,
# где установлен SDK и библиотека mocker
APPENGINE_PATH = '../google_appengine'
MOCKER_PATH = '../mocker-0.10.1'

# Добавление необходимых для app-engine библиотек к пути интерпретатора
paths = [
    APPENGINE_PATH,
    os.path.join(APPENGINE_PATH, 'lib', 'django'),
    os.path.join(APPENGINE_PATH, 'lib', 'webob'),
    os.path.join(APPENGINE_PATH, 'lib', 'yaml', 'lib'),
    MOCKER_PATH,
]
for path in paths:
  if not os.path.exists(path):
    raise 'Path does not exist: %s' % path
sys.path = paths + sys.path
import mocker

Определение и запуск тестов

Мы только что настроили нашу программу для использования с необходимыми компонентами для проведения тестирования и готовы к созданию первого теста. Сначала задаем класс-наследник от MockerTestCase, который содержит объект "self.mocker", представляющий собой ссылку на интерфейс, контролирующий проведение тестов и выполняющий после них очистку данных. В данном примере я создаю экземпляры классов обоих обработчиков и задаю объекты request и response как заглушки. Если будет вызван метод, который не ожидался, то тест будет считаться непройденным. Я также выполняю замену модулей users, templates и модель Greetings аналогичными заглушками (зачем выполнять проверку содержимого сгенерированного html вместо того, чтобы проверить сами параметры?):

import helloworld

class UnitTests(mocker.MockerTestCase):
  """Тесты для обработчиков MainPage и GuestBook."""

  def setUp(self):
    self.request = self.mocker.mock()
    self.response = self.mocker.mock()
    self.handler1 = helloworld.MainPage()
    self.handler2 = helloworld.Guestbook()
    self.handler1.request = self.request
    self.handler1.response = self.response
    self.handler2.request = self.request
    self.handler2.response = self.response
    self.Greeting = self.mocker.replace('helloworld.Greeting')
    self.users = self.mocker.replace('google.appengine.api.users')
    self.template = self.mocker.replace('google.appengine.ext.webapp.template')

Теперь все готово для составления первого теста. Он будет проводить проверку поведения метода MainPage.get() при условии авторизации пользователя (если вы не знакомы с этим методом, то вам сюда). Простейшим способом сделать это является подробное описание в нашем фреймворке каждого вызова, которое выполняет приложение. Следующий код симулирует запрос к хранилищу, который загружает данные и выдает 10 первых результатов. Обратите внимание, что нам на самом деле не нужно получать какие-либо объекты -- они просто не требуются для этого теста. Мы будем возвращать строку с значением Query result for template.

  def testGetWhenLoggedIn(self):
    # Что может произойти во время обычного запроса?
    # Сначала мы загрузим все сообщения
    all_query = self.mocker.mock()
    self.Greeting.all()
    self.mocker.result(all_query)
    ordered_query = self.mocker.mock()
    all_query.order('-date')
    self.mocker.result(ordered_query)
    ordered_query.fetch(10)
    self.mocker.result('Query result for template')

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

    fake_user = self.mocker.mock()
    self.users.get_current_user()
    self.mocker.result(fake_user)
    self.request.uri
    self.mocker.result('fake uri')
    self.users.create_logout_url('fake uri')
    self.mocker.result('fake logout uri')

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

    out = self.mocker.mock()
    self.response.out
    self.mocker.result(out)
    self.template.render(mocker.ANY, mocker.ANY)
    def checkArgs(path, params):
      template_values = {
        'greetings': 'Query result for template',
        'url': 'fake logout uri',
        'url_linktext': 'Logout',
        }
      self.assert_(path.endswith('index.html'))
      self.assertEqual(template_values, params)
      return '<html/>'
    self.mocker.call(checkArgs)
    out.write('<html/>')

Мы закончили моделировать ожидаемые данные: представили что текущий пользовать был авторизован и задали нормальное поведение обработчика.

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

    # Все что надо было - записано, теперь можно устроить прогон теста :-)
    self.mocker.replay()
    self.handler1.get()

# #####################
#  ЗАПУСК ВСЕХ ТЕСТОВ
# #####################
if __name__ == "__main__":
  unittest.main()

Все ли правильно?

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

    # TODO: переделать тест?
    greeting.put()
    self.handler2.redirect = lambda x: self.assertEquals('/', x)

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

    # TODO: переделать тест?
    greeting.put()
    mock_redirect = self.mocker.mock()
    self.handler2.redirect = lambda x: mock_redirect.redirect(x)
    mock_redirect.redirect('/')

Хотя это, безусловно, улучшение кода, оно все еще далеко от идеала. Что будет, если кто-то изменит обработчик и добавит в него вызов метода error()? Все тесты пойдут насмарку! Или, что еще хуже, если кто-то решил перекрыть метод redirect в обработчике? В этом случае тест будет всегда признан состоявшимся, несмотря на то, что новый метод может быть нерабочим.

Я не уверен, что это идеальное решение, но я попробовал переделать тест и производить вызов метода post напрямую от mock-объекта, передавая ему ссылку на обработчик Guestbook:

  def testPostWhenLoggedOut(self):
    handler3 = self.mocker.mock(helloworld.Guestbook)
    handler3.request
    self.mocker.count(0,10)
    self.mocker.result(self.request)
    handler3.response
    self.mocker.count(0,10)
    self.mocker.result(self.response)

    # Сначала создается новое приветствие
    greeting = self.mocker.mock()
    self.Greeting()
    self.mocker.result(greeting)

    # Пользователь не авторизован
    self.users.get_current_user()
    self.mocker.result(None)

    # Далее извлекается за запроса параметр content
    self.request.get('content')
    self.mocker.result('mock content')
    greeting.content = 'mock content'

    # Теперь сохраняем пост и выполняем перенаправление
    greeting.put()
    mock_redirect = self.mocker.mock()
    handler3.redirect('/')

    # Все что надо было - записано, теперь можно устроить прогон теста :-)
    self.mocker.replay()
    helloworld.Guestbook.post(handler3)

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

It's a great time to program for the cloud, no matter what Ted Dziuba's entertaining but barely coherent rants have to say (will someone get that guy some experience?). Amazon and Google are going toe-to-toe, with Amazon's addition of sorting in Simple DB bringing it up to par with Google App Engine's Datastore API. Sorting was the biggest missing piece in Simple DB and the most compelling reason to choose the Datastore API instead. No longer.  

But Google App Engine (GAE) and the Datastore API still win. Here's why:

1. The Datastore API is projected to be 10x cheaper. $0.15-$0.18 per GB-month sounds a lot better than Simple DB's $1.50 per GB-month.
2. GQL. GAE's SQL subset is just brain dead simple. As adept as programmers are at learning new frameworks, it's nice to have something brain dead every once in awhile. Simple DB takes a few more cycles to learn (brain cycles that is -- more coffee and such. Modafinil perhaps? Anyone tried it? I'm curious).
3. GAE has better Object Relational Mapping (ORM). GAE basically uses Django's sweet ORM system. You've got to jump through a lot more hoops to get something as nice with Simple DB. 
4. GAE automatically scales the web application, not just the database. With Amazon, you have to add load balancing and bring machines up and down yourself, even if you're using Simple DB. While there are third-party tools to help, they're not built-in. Again, GAE is brain dead here.  

Sure, App Engine only supports Python. The ultimate question, though, is what functionality can you get in the end? For web apps, App Engine gives you more, particularly for scaling (which is kind of the whole point). Don't know Python? Learn it. It will save you time in the end. Instead of endlessly fiddling with your load balancer and custom scripts for bringing instances up and down, you'll spend your time adding the next killer feature your users will love.

In the end, the Amazon/Google "main event" is a huge win for you, me, and our users. The sorting announcement from Amazon comes on the heals of a flurry of other new features from both companies, including Amazon's impressive persistent storage addition for EC2 called the Elastic Block Store, querying by attributes on Simple DB, GAE's support for 10 applications per user instead of 3, GAE's batch writes, etc. Neither one is pulling any punches, and the tools at our disposal as developers are progressing at a breathtaking pace as a result.

Amazon's is clearly the more complete offering (you can do anything on it, in any language), but it needs to learn from Google's focus on the dominant deployment scenarios.  Amazon could easily win if it does the following:

1. Makes Simple DB pricing competitive with Google's projected prices.
2. Adds a query language for Simple DB along the lines of GQL.
3. Adds automatic scaling for web applications, not just the database.
4. Offers complete deployment solutions for the dominant web applications frameworks, from Tomcat/Spring/Hibernate to Django and Zend, with ORM models already adapted to Simple DB, instances automatically replicated with traffic, etc. Basically the same thing as App Engine for more web app frameworks than App Engine supports and adapted to the Amazon platform. Sure, there are third-party solutions for some of this stuff, but those will never be trusted as much as something offered directly from Amazon.

I'm a big fan of Amazon and Werner Vogels (one of the most innovative people in the industry, and also apparently a pretty nice guy), but Amazon desperately needs to learn from what Google has done. It's ultimately a question of "usability" for developers. The originators of "one-click shopping" are losing in the game they practically invented. 

Amazon needs to turn on the one-click cloud.

The badness is that GAE's datastore doesn't appear to have any sort of inherint journaling or rollback features, so if something gets funky in the data there aren't any breadcrumbs to follow to get a clue as to how it got that way, nor is there a way to rollback to the last known good state.  Even bulk downloading and uploading of data isn't inherently supported to try to do just a straight off-site backup of a good state and then a restore of that state from the off-site backup.  Using a standard hosting a site, at a minimum you could occasionally backup your SQLite file right on the server and just replace it if things got wonky.  Obviously SQLite doesn't scale very far.  Other SQL DBs have their scalability limites as well.  So it looks likes its either write your data distribution code or write your own journaling and rollback code.  GAE's datastore and API also don't appear to allow modifications of the existing schema either.  If you add a field to an entity in the code when you try to load an existing entity it will fail, so you can really only make additions.

I'll think I'll still forge ahead with GAE for my first web browser based strategy game just for the experience, but I'm definitely feeling more motivated to go back and work on the distributed app platform I've been wanting to work on.

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

Одним из решений проблемы является составление списка разрешенных пользователей (либо получения его из базы данных). Это годится в том случае, если вы знаете кто же допущен к сайту, но к сожалению требует постоянного изменения этого списка и поддержания его в актуальном состоянии. Другим интересным методом является использование системы инвайтов (приглашений), как той, какую на начальном этапе имел Gmail, но это тоже означает, что-то должен управлять этими приглашениями. Следующий пример показывает работу золотой середины между этими описанными методами -- технология, названная HMAC, которая позволяет убедиться, конкретный аккаунт Google имеет право доступа.

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

import base64
from openid import cryptutil

def sign(username):

  # В реальной жизни выберите лучший секретный ключ!
  secret='superSecretKey'
  return base64.encodestring(
      cryptutil.hmacSha1(secret, username))

Так как эта проверка работает на практике? Давайте посмотрим на простой обработчик запросов, который будет использовать ее:

import cgi
import os
import urllib
import wsgiref.handlers

from google.appengine.api import users
from google.appengine.ext import webapp

class MainPage(webapp.RequestHandler):

  def isValid(self):
    """Определение, что заданный запрос валиден.

       Для выполнения этих критериев, текущий пользователь должен
       быть авторизован и быть либо администратором, либо передать
       в запросе зашифрованный параметр, совпадающий с его именем пользователя.
    """
    user = users.get_current_user()
    if not user:
      return False
    if not users.is_current_user_admin():
      expected_signature = sign(user.email().lower())
      given_signature = self.request.get('signature')
      if not given_signature == expected_signature:
        return False
    return True

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

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

  def get(self):
    """Отображение сообщения только для приглашенных пользователей."""

    # Требуется авторизация
    user = users.get_current_user()
    if not user:
      self.redirect(users.create_login_url(self.request.uri))
      return

    # Если пользователь не администратор, проверить подпись
    if not self.isValid():
      self.error(403)
      return

    # Ok, пользователь допущен к просмотру страницы!
    # В реальной жизни мы воспользуемся в этом месте
    # шаблоном ;-)
    self.response.out.write("""
        <html><body>
        <h1>Hello, %s</h1>
        <p>Ниже секретное сообщение, которое вы ищете:
           &nbsp;<b>APP ENGINE РУЛИТ!!!</b>
        </p>
        <form method="POST">
        Передать сообщение другу
        <input name="invitee"/> &nbsp;
        <input type="submit"/></form>
        <p><a href="%s">Log out</a></p>
        </body></html
        """ % (cgi.escape(user.nickname()),
               users.create_logout_url(self.request.uri)))

  def post(self):
    """Создание строки URL для последующей отправки приглашенному."""

    # Если пользователь не администратор, проверить подпись
    if not self.isValid():
      self.error(403)
      return

    # Получить имя invitee
    invitee = self.request.get('invitee')
    if not invitee:
      invitee = 'anonymnous'
    invitee = invitee.lower()

    # подписать инвайт и вывести url
    signature = sign(invitee)
    self.response.out.write("""
        <html><body>
        URL для друга:
        http://%s?signature=%s</body></html>""" % (
            os.environ['SERVER_NAME'],
            urllib.quote(signature, '')))

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

На выходных Jaiku снова стал недоступен, но в официальном блоге содержится информация о том, что это произошло из-за его переноса на инфраструктуру Google. "Теперь мы можем подтвердить, что сервис уже работает на платформе Google App Engine и мы снова доступны всему миру," говорится в сообщении JaikuInvites. Содержимое страниц, загружаемых с Jaiku.com, также сообщает о том, что они обслуживаются сервером 'Google Frontend'. Google Frontend - это сервер, который используется для работы всех приложений Google App Engine. GFE также задействован для хостинга проекта Blogger в домене blogspot.com, хотя пока Google для других сервисов все еще использует GWS (Google Web Server).

Проект называется Gapproxy, распространяется в исходных кодах и уже имеет лояльную аудиторию преданных пользователей. Суть проста: типичный китаец, который хочет попасть на сайты, куда его не очень-то и хотели пускать (например, Китайскую Википедию) скачивает простой агент, который принимает HTTP запросы на локальном компьютере на порту 8000. На его же использование настраиваются все браузеры, аськи и прочие клиенты, которым необходимо преодолеть запретный барьер. Далее этот агент при поступлении запроса выполняет такой же к специальному приложению на App Engine, которое в свою очередь делает обращение к нужному ресурсу. Получается такая четырехзвенная структура, способная работать с любыми приложениями по протоколам HTTP и HTTPS.

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

Сначала следует упомянуть пакетную запись. Теперь вы можете включить объекты из нескольких различных групп в одну операцию db.put() или db.delete(). Изменения объектов будут являться атомарными операциями только в рамках отдельной группы объектов, но использование одного обращения к хранилищу вместо нескольких отдельных последовательных вызовов, которые требовались ранее, более эффективно.

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

Kind: Post
 properties:
 - name: tag
 - name: tag

Такие индексы будут полезны в некоторых случаях; смотрите раздел Запросы и индексы для дополнительной информации.

Ну и как обычно, обновите свой SDK и просмотрите включенный в него полный список изменений в системе.

I thought I'd give Appcelerator a try, since it can create project for Google's App Engine. I noticed that they have a plug-in for Eclipse; however, after installing Eclipse and their plug-in I found that their project wizard was throwing an exception at the last step. It may be that they expect the Eclipse install to include certain thing such as a Java development environment (I had installed the C/C++ only distro), but I they have a command line tool for creating projects as well, so I gave that a shot. I was able to run the created project locally and deploy it to App Engine and run it successfully there as well. However, I found that the project was not setup to use Pylons as I had mistakenly gotten the impression that it would be. I created a Appcelerator project for Python rather then AppEngine with their command line tool and I found that that project did use Pylons and it shouldn't be terribly difficult to get that project up and going on App Engine by following these directions. I also found that the default generated index page was HTML 4.01 rather then XHTML 1.0 and after switching it over, I found that a number of the Appcelerator specific things wouldn't pass validation (the original HTML 4.01 version didn't pass validation either).

As I'd like my first web app to actually serve up pages that are valid, that means no Appcelerator for me. I also have a strong desire to not be involved with javasript in any way shape or form. I was willing to live loading a third party script I never needed to touch, but I noticed that the example for some of the Appcelerator widgets involved adding app specific javascript.

I'm going to start over with a pure Pylons project and then go back to trying to get my CSS stylings to work in both FireFox and IE. IE doesn't seem to be handle things tagged with float as well as FireFox so I may just throw in the towel on having a dynamic layout that will adapt to different width windows and just go with a fixed width of that will work on a display 800 pixels wide.

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

Сам код очень тривиален:

# coding=UTF-8
# -*- coding: utf-8 -*-

import wsgiref.handlers
from google.appengine.ext import webapp
from google.appengine.api import urlfetch
import re
import logging

allowed_headers = ('content-type', 'Content-Type', 'Set-Cookie', 'set-cookie')
HOST = 'gproxyru.appspot.com'

def add_header(self, header, info):
    if header == 'Content-Type':
        self.response.headers['Content-Type'] = info
        return
    if (header == 'Set-Cookie') or (header == 'set-cookie'):
        cookies = re.split(', ', info)
        for cookie in cookies:
            # Убираем требования по безопасности
            cookie = re.sub('secure; ', '', cookie)
            self.response.headers.add_header('Set-Cookie', cookie)
        return
    self.response.headers.add_header(header, info)
    logging.error(header + ': '+ info)

def process_page(self, url, method, mode='http'):
    hm = re.findall('//(.*)/', url)
    if len(hm) == 0:
        hostname = re.findall('//(.*)', url)[0]
    else:
        hostname = hm[0]
    result = urlfetch.fetch(url, method=urlfetch.GET)
    # меняем все ссылки в документе http:// на http://HOST/http/ и тому подобное
    content = re.sub('http://', 'http://' + HOST + '/http/', result.content)
    content = re.sub('https://', 'http://' + HOST + '/https/', content)
    # относительные источники изображений
    content = re.sub(' src=/', ' src=/'+ mode +'/' + hostname + '/', content)
    content = re.sub(' src="/', ' src="/'+ mode +'/' + hostname + '/', content)
    # href для CSS и A
    content = re.sub(' href=/', ' href=/'+ mode +'/' + hostname + '/', content)
    content = re.sub(' href="/', ' href="/'+ mode +'/' + hostname + '/', content)
    # ссылки для форм
    content = re.sub(' action=/', ' action=/'+ mode +'/' + hostname + '/', content)
    content = re.sub(' action="/', ' action="/'+ mode +'/' + hostname + '/', content)
    self.response.out.write(content)
    for header in result.headers.keys():
        if header in allowed_headers:
            add_header(self, header, result.headers[header])

class Http(webapp.RequestHandler):
    def url(self):
        res = re.search('/http/(.*)', self.request.url)
        if res != None:
            return 'http://' + res.group(1)

    def get(self):
        process_page(self, self.url(), urlfetch.GET)

    def post(self):
        process_page(self, self.url(), urlfetch.POST)

class Https(webapp.RequestHandler):
    def url(self):
        res = re.search('/https/(.*)', self.request.url)
        if res != None:
            return 'https://' + res.group(1)         

    def get(self):
        process_page(self, self.url(), urlfetch.GET, mode='https')

    def post(self):
        process_page(self, self.url(), urlfetch.POST, mode='https')

class MainPage(webapp.RequestHandler):
    def get(self):
        self.response.out.write("""<h3>Простенький анонимный прокси-сервер от Google</h3>
                                <form action='/go'>
                                Введите сайт, например <b>www.google.ru</b>: <input name=q size=70>
                                <input type=submit value="Перейти">
                                </form>
                                """)
class Q(webapp.RequestHandler):
    def get(self):
        q = self.request.get('q')
        if re.match('http://', q):
            self.redirect('/http/' + q[7:])
            return
        if re.match('https://', q):
            self.redirect('/https/' + q[8:])
            return
        self.redirect('/http/' + q)

def main():
    application = webapp.WSGIApplication(
                                         [('/', MainPage),
                                          ('/go', Q),
                                          ('/http/.*', Http),
                                          ('/https/.*', Https)
                                         ],
                                         debug=True)
    wsgiref.handlers.CGIHandler().run(application)

if __name__ == '__main__':
    main()

Посмотреть работу вживую можно на сайте gproxyru.appspot.com. Ниже приведен пример, как Mail.Ru определил наше местоположение как Вашингтон:

Недостатки:

• хотя сайты по протоколу HTTPS прекрасно открываются, передача данных на участке от клиента до датацентра Google проходит без шифрации
• на данный момент никак не реализована работа с куками (хотя для анонимности, может быть это и хорошо ;-) )
• замена ссылок в коде страницы для быстроты реакции производится регулярными выражениями, возможно, это не самый правильный способ
• существуют мелкие недочеты в виде нарушения работы кода JavaScript, либо, наоборот, невозможности скрыть IP адрес от таких скриптов.

Все сообщения о проблемах кроме сайта дублируются в Twitter.

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

Ниже приведен пример получения сообщения при использовании фреймворка webapp:

from google.appengine.ext import webapp
import email

class EmailHandler(webapp.RequestHandler):
  def post(self):
    sender = self.request.GET.get("from", "")
    recipient = self.request.GET.get("to", "")
    message = email.message_from_string(self.request.body)
    # Произвести обработку сообщения

Исходный код полностью открыт.

Apple's MobileMe went on the blink for many while the GMail blackout that left millions angry and frustrated. Even Amazon's seemingly fool proof S3 service was down for an extended period of time, impacting thousands of its customers. This isn't the last we have seen of these outages. As the size and scope of cloud computing grows, so will the problems and the need for tools to monitor the clouds.

Enter San Francisco-based web infrastructure monitoring service provider Hyperic, which recently launched CloudStatus, a hosted real-time cloud monitoring service to keep an eye on cloud–based services. Thus far CloudStatus is monitoring Amazon's web services, but sometime later today, the company will start monitoring Google's App Engine infrastructure, a move that has been blessed by the search engine giant. The service, still in beta testing phase, is free for near foreseeable future, but company might charge for premium services at a later date.

To describe it in super-simplistic terms, this is how the service works: Hyperic has developed an application that runs on the Google App Engine and essentially sends all sorts of information to an agent sitting in Hyperic's data center, which in turn passes it onto Hyperic's main offering. Through a web-browser interface, folks can in turn keep an eye on the status of the cloud.

What will it do for Google App Engine users? Javier A. Soltero, CEO of Hyperic said that it will help users answer questions like "How fast is the App Engine cache service running?" or "What's the response time to Facebook's API from App Engines perspective?" and other such questions that can help keep apps healthy.

The company can do this is because it is based on agents that are deployed both inside and outside the "cloud infrastructure" and are specialized for the kind of services they monitor. A storage agent, for instance may monitor latency, throughput and remaining capacity. A compute engine agent would monitor load, availability and response times.

Taking measurements from both sides of the wall -- that is, from inside the cloud providers operation, and from the outside looking in -- gives Hyperic an advantage, says Soltero, who claims that it "picked up the Amazon S3 problems about 20 minutes before Amazon announced (the outage.)" He explained that the service is capable of monitoring any number of different clouds, and it will add more cloud providers to the list.

For Hyperic, CloudStatus is a chance to stand out amongst its competitors. While companies like Stubhub, Comcast and CNET have adopted Hyperics web monitoring tools, the company has little traction inside the enterprises. On the web-side, several companies such as Gomez, Keynote and Webmetrics offer Hyperic-like services.

Cloud computing, however, is a new game where Hyperic can make a play to win -- though it would need to add depth and value to its offerings. After all, looming in the background is the distinct possibility that some day Amazon and Google will rollout their own monitoring services.

Используйте функцию os.getcwd() или переменную окружения os.environ['PATH_TRANSLATED']

>>> os.getcwd()
'/base/data/home/apps/shell/1.21'
>>> os.getcwd().split('/')[-2]
'shell'
>>> os.getcwd().split('/')[-1]
'1.21'

>>> os.environ['PATH_TRANSLATED']
'/base/data/home/apps/shell/1.21/shell.py'
>>> os.environ['PATH_TRANSLATED'].split('/')[-3]
'shell'

Как определить текущий хост?

Есть один очень интересный файл, который уникален на каждом сервере:

>>> open('/base/python_dist/search.config').read()
'datapath .\nsorttempdir .\ndisk /export/hdc3/borgletdata/dirs/prod-appengine.\
mpm_python_dist_v12.apphosting.77627982/bigfiledata/466024'

>>> open('/base/python_dist/search.config').read()
'datapath .\nsorttempdir .\ndisk /export/hdc3/borgletdata/dirs/prod-appengine.\
mpm_python_dist_v12.apphosting.77627739/bigfiledata/465336'

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

def get_server_id():
    try:
        fd   = open('/base/python_dist/search.config')
        data = fd.read()
        fd.close()
    except IOError:
        return 'unknown'

    return '%s' % data.__hash__()

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

$ for i in `seq 20`; do
    curl -s http://cometchat.appspot.com|\
    grep server_id; \
  done    |sort -n|uniq -c

     20 server_id: '7341146770217830363'

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

Как можно идентифицировать текущий процесс?

И следующий вопрос: сколько процессов моего приложения запущено на одном сервере? Можно проанализировать с помощью глобальной переменной:

the_process_global = "something"

def get_process_id():
    return '%s' % id(the_process_global)

Теперь мне известно, что приложение задействует два процесса:

$ for i in `seq 20`; do
    curl -s http://cometchat.appspot.com|\
    grep _id;
  done    |sort -n|uniq -c

    13 process_id: '12457625149327067176'
     7 process_id: '3996238433791648184'

Работаем ли мы в среде разработки или на сервере?

Я использую такой шаблон:

if os.environ.get('SERVER_SOFTWARE','').startswith('Devel'):
    HOST='local'
elif os.environ.get('SERVER_SOFTWARE','').startswith('Goog'):
    HOST='google'
else:
    # logging.error('Неизвестный сервер?')
    HOST='unknown'

Cookies?

Google в своем интерфейсе определило объекты request и response как наследники соответствующих классов из библиотеки WebOb. Таким образом мы можем из объекта request получить содержимое cookie запроса:

username = self.request.cookies.get('username', '')

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

self.response.headers.add_header(
        'Set-Cookie',
        'username=%s; expires=Fri, 31-Dec-2020 23:59:59 GMT' \
          % username.encode())

Дополнительные методы работы с cookie есть в группе обсуждения на английском языке.

Отладка работы с данными хранилища

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

К примеру:

class List(debug.DebugMiddleware):
    def get(self):
        ... blabla ...

Отдалочная информация будет выглядеть так:

**** Request took:   830ms/170ms (real time/cpu time)
**** GQLs, datastore accessed 1 times.
98ms GQL app: ":self"
            kind: "Image"
            Order {
            property: "modified"
            direction: 2
            }
            args: (50,) {}

GQL запрос, который сгенерировал ее:

ims = Image.all().order("-modified").fetch(50)

Другой пример отладочной информации:

**** Request took:   150ms/130ms (real time/cpu time)
**** GQLs, datastore accessed xx times.
  219ms PUT ({'full':...
  178ms PUT ({'full':...
    6ms GET ([datastore_types.Key.from_path('Image', 350L, _app=u'srv')],) {}
    2ms GET ([datastore_types.Key.from_path('Image', 349L, _app=u'srv')],) {}
    2ms GET ([datastore_types.Key.from_path('Image', 348L, _app=u'srv')],) {}

Этот отладчик очень удобно использовать в Django.

Динамическая загрузка изображений на сервер

Вот код, который я использую:

<form action="." method="post" enctype="multipart/form-data">
    <label>File: </label><input name="file" type="file"><br />
    <input type="submit">
</form>

На стороне сервера:

class Image(db.Model):
    name        = db.StringProperty()
    content     = db.BlobProperty()

class UploadImage(webapp.RequestHandler):
    def post(self):
        if 'file' not in self.request.POST:
            self.error(400)
            self.response.out.write("Файл не указан!")
            return

        if (self.request.POST.get('file', None) is None or
           not self.request.POST.get('file', None).filename):
            self.error(400)
            self.response.out.write("Файл не указан!")
            return

        file_data = self.request.POST.get('file').file.read()
        file_name = self.request.POST.get('file').filename

        im = Image()
        im.name    = file_name
        im.content = file_data
        im.save()
        self.response.out.write("Изображение %r сохранено." % im.name)

Как определить размер и тип изображения

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

content_type, width, height = getImageInfo(im.content)

Динамическая работа с изображениями

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

class ServeImage(webapp.RequestHandler):
    def get(self, key):
        im = db.get(db.Key(key))
        if not im:
            self.error(404)
            return

        content_type, width, height = getImageInfo(im.content)
        self.response.headers.add_header("Expires", "Thu, 01 Dec 2014 16:00:00 GMT")
        self.response.headers["Content-Type"] = content_type
        self.response.out.write(im.content)

Когда платформа Google App Engine была впервые представлена широким массам, многие недоумевали, почему в Datastore API не реализован полнотекстовый поиск. Очень странно - бизнес Google основан по поиске, однако эти новое передовое решение его не поддерживает!

На сегодняшний момент интерфейс Google App Engine имеет примитивную реализацию полнотекстового поиска данных в хранилище, скрытую в недрах модуля google.appengine.ext.search. (По которому практически нет никакого описания, кроме самих исходных кодов). Вы можете использовать этот модуль, создавая модели наследники от класса search.SearchableModel, вместо обычного db.Model.

К примеру так:

from google.appengine.ext import db
from google.appengine.ext import search

class Article(search.SearchableModel):
  title = db.TextProperty()
  publishDate = db.DateTimeProperty(auto_now_add=True)
  text = db.TextProperty()

# НЕ индексируется
article = Article(text ='''This is the totally secret article text
which talks about sausages and cheese in the middle of itself.''')
article.title = "Fine cuisine"
article.save() 

# индексируется
article = Article()
article.title = "What I feed my dogs"
article.text = '''This is the totally secret article text
which talks about sausages and cheese in the middle of itself.'''
article.save() 

print "Результаты"

query = Article.all().search("sausages cheese dogs").order("-publishDate")
for a in query:
  print "%s | %s" % (a.title, a.publishDate)

print "Конец вывода"

Ограничения

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

Латентность

Философия работы хранилища заключается в том, что на сегодняшний момент дисковое пространство очень дешево, и соответственно выполнять обработку данных следует при сохранении объекта. Таким же образом работают модели SearchableModel, при вызове метода save() они выполняют построение индексов. Это означает, что модели типа SearchableModels будут работать всегда медленее стандартных моделей. Имейте всегда это ввиду.

Индекс индекса

Как вы знаете, пакет разработки Google App Engine SDK создает описание для всех необходимых индексов в файле index.yaml, для которых возникает потребность при разработке приложения. Однако, если вы не имеете возможности провести тесты приложения, покрывающие целиком все его запросы, тогда необходимо добавить описания соответствующих индексов в файл index.yaml вручную. В этих случаях необходимо учесть, что полнотекстовый индекс содержится в свойстве с именем __searchable_text_index. К примеру, индекс можно определить как:

  - kind: Article
    properties:
    - name: __searchable_text_index
    - name: publishDate
      direction: desc

Это все о работе полнотекстового поиска в App Engine. Пока он не поражает обилием своих возможностей, однако этого хватит для большинства применений.

На сайте Vimeo выложен пример, показывающий начало разработки с Web2Py:

Модель:

from appengine_django.models import BaseModel
from google.appengine.ext import db

class AlbumItem(BaseModel):
  creationDate = db.DateTimeProperty(auto_now_add=True)
  image = db.BlobProperty(required=True)
  note = db.StringProperty()

Отображение формы:

class AlbumItemForm(ModelForm):
 image = FileField()
 note = CharField(widget=Textarea)

 class Meta:
  model = AlbumItem
  exclude = ("creationDate")

def albumentry(request):
 if request.POST:
  form = AlbumItemForm(request.POST, request.FILES)
  if form.is_valid():
   albumEntry = form.save()
   return HttpResponseRedirect('/showalbumentry/%s' % albumEntry.key())
  else:
   return render_to_response('albumentry.html', locals())
 else:
  form = AlbumItemForm()
  return render_to_response('albumentry.html', locals())

Содержимое указанного в коде файла шаблона albumentry.html тривиально, мы не будем полностью описывать его. Главное поместите в код формы шаблонную переменную {{form}} и не забудьте выставить атрибут enctype="multipart/form-data" в теге <form>.

Все работает автоматически - содержимое файла с изображением, загружаемое на сервер, будет помещено в свойство image. Используемый код работает на версиях App Engine SDK 1.1, Django Helper r30 и Django 0.97.

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

С чего начать?

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

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

После регистрации в сервисе, вам потребуется простой класс на языке

Python, адаптированный для App Engine. Скачать его можно здесь. После загрузки переименуйте его в captcha.py и скопируйте в каталог приложения (я предпочитаю размещать его в подкаталоге recaptcha/client/ - не забудьте добавить к каждому подкаталогу пустой файл __init__.py).

Для демонстрации работы мы дополним стандартный пример из Руководства для начинающих Google App Engine.

Откройте файл helloworld.py и добавьте строчки импорта модулей captcha и environ:

from os import environ
from recaptcha.client import captcha

Затем перейдите к контроллеру MainPage и добавьте следующее:

chtml = captcha.displayhtml(
  public_key = "ВАШ-ПУБЛИЧНЫЙ-КЛЮЧ",
  use_ssl = False,
  error = None)

template_values = {
   ...
   'captchahtml': chtml
}

Соответственно замените выражение ВАШ-ПУБЛИЧНЫЙ-КЛЮЧ своим ключом, иначе получите ошибку:
"Invalid public key. Make sure you copy and pasted it correctly."

Теперь перейдите к файлу с шаблоном и добавьте тэг captchahtml внутри формы:

<form>
  ...
    {{ captchahtml }}
</form>

После этого можно открыть свой браузер и увидеть reCAPTCHA в отдельном iframe:

Теперь после того, как получены отправленные через форму данные, нам необходимо выполнить проверку того, что в катпчу введен правильный код. Мы проведем изменение метода post класса Guestbook и добавим код:

def post(self):
  challenge = self.request.get('recaptcha_challenge_field')
  response  = self.request.get('recaptcha_response_field')
  remoteip  = environ['REMOTE_ADDR']

  cResponse = captcha.submit(
                 challenge,
                 response,
                 "ВАШ-ПРИВАТНЫЙ-КЛЮЧ",
                 remoteip)

    if cResponse.is_valid:
        # код введен верный
        # продолжаем работу приложения
    else:
      error = cResponse.error_code
    ...

Аналогично, замените выражение ВАШ-ПРИВАТНЫЙ-КЛЮЧ ранее полученным приватным ключом.

Информация, введенная пользователем в поле reCAPTCHA будет отправлена на проверку вместе с его IP адресом. Мы получим ответ от сервера reCAPTCHA в формате объекта RecaptchaResponse.

Объект RecaptchaResponse имеет два атрибута:

• is_valid, установленный в True, если тест был пройден удачно (в противном случае False)
• error_code , содержащий код ошибки API, если произошла какая-то проблема.

Примечание: В Руководстве для начинающих Google App Engine, информация введенная в формы, передавалась контроллеру Guestbook. В обычном случае мы будем передавать ее в контроллер MainPage, и обрабатывать код ошибки из объекта RecaptchaResponse (если он будет) методом displayhtml класса captcha:

chtml = captcha.displayhtml(
  public_key = "ВАШ-ПУБЛИЧНЫЙ-КЛЮЧ",
  use_ssl = False,
  error = cResponse.error_code)

Это позволит вывести читаемое сообщение об ошибке пользователю:

и дать ему возможность еще раз ввести ответ на CAPTCHA без необходимости повторного ввода других данных в поля формы.

Имейте ввиду: Для каждой отправленной пользователем CAPTCHA, выполняется удаленный запрос к серверу reCAPTCHA. Этот запрос является синхронным, и таким образом посетитель будет ждать некоторое время, пока сервер обработает этот запрос. В том случае, если сервер reCAPTCHA в этот момент не был доступен, будет возвращен код ответа recaptcha-not-reachable.

Выбираем Search new features to install и нажимаем на кнопку Next >:

В появившемся окне нажимаем кнопку New remote site:

Далее заполняем поля Name названием расширения Subclipse и указываем его адрес в поле URL: http://subclipse.tigris.org/update_1.4.x. Убеждаемся, что в главном окне установлена галочка на вновь добавленном сайте Subclipse:

Нажимаем кнопку Finish. В следующем окне выбираем опции SVNKit Adapter и Subclipse. Щелкаем по кнопке Next >:

Далее принимаем условия лицензионного соглашения:

На следующем экране проверяем выбранные опции установки и жмем по кнопке Finish:

Ну и напоследок щелкаем по кнопке Install All:

После проведения установки, Eclipse сообщит нам, что необходимо перезапустить среду для применения изменений:

В завершении м