Google App Engine

GAE tilbyr ikke en vanlig relasjonsdatabase (som MySQL, MS SQL osv) men noe som kalles Datastore, denne er i tillegg begrenset til å ikke hente ut mer enn maks 1000 poster fra en “tabell”. Biblioteket som Google stiller med støtter heller ikke sesjoner (sessions), men man kan bygge dette ut ved å legge ved egne biblioteker. En annen artig begresning er at koden ikke kan lese eller skrive til disk. Når dette er sagt stiller man med Memcache, noe som kan sammenlignes med delt minne tilgjengelig fra alle instansene som kjører (for Google kan finne på å kjøre opp applikasjonen på mange for å skallere).

Jeg oppdaget GAE gjennom en artikkel i Python Magazine, og fant det utrolig interessant, men av mangel på applikasjoner å utvikle ble det lagt litt på hylla helt til for noen dager siden når jeg kom over en video på YouTube som viste ting i praksis, og da måtte det bare testes.

For å vise litt av mulighetene i GAE skal jeg utvikle en liten applikasjon som viser et tilfeldig sitat fra datastore, og som lar Google sine brukere logge på for å legge inn nye sitater. Det skal også være en link til hvert sitat.

For å utvikle kan man laste ned App Engine SDK, og da Google støtter kun Python i skrivende stund blir dette utviklingsspråket som må benyttes.

Til å begynne med lager jeg en modell, en representasjon av “tabellen” jeg skal benytte.

class Quote(db.Model):
id = db.IntegerProperty()
user = db.UserProperty(required=True)
name = db.StringProperty()
text = db.StringProperty(multiline=True, required=True)
timestamp = db.DateTimeProperty(auto_now_add=True)

Det er lite spennende her, men det er verdt å merke seg at UserProperty lar deg lage en representasjon av Google sine brukere. Så snart modellen er laget kan jeg begynne å legge inn data i den ved hjelp av kode. For å lage siden må jeg definere en klasse for dette.

class Add(Base):
def get(self):
self.render("add.html")

def post(self):
q = Quote(
text = self.request.get("text"),
name = self.request.get("name"),
user = users.get_current_user()
).put()
self.redirect("/view/" + str(q.id()))

Ved GET-etterspørsler vil get-metoden benyttes, og den returnerer en nettside. Ved POST-etterspørsel vil det bli opprettet et nytt objekt med informasjon, og ved hjelp av put() blir objektet lagret i datastore, for så å sende brukeren til en side som viser det nye objektet.

Det er viktig å merke seg at det ikke finnes noen mulighet for auto increment som man kjenner fra andre databaser, så id-feltet som ser ut til å ligge lagret i modellen inneholder None (null). For å simulere auto increment er det laget to metoder som tar var på den siste id-verdien i memcache.

def getLast():
last = memcache.get("last")
if last:
return last
return setLast()

def setLast():
id = Quote.all().order("-id").get().id
memcache.set("last", id, 3600*24)
return id

Ved hjelp av setLast blir den siste verdien hentet ut og lagt inn i memcache, som kan beskrives som delt minne mellom instansene av applikasjonen (Google starter ikke bare én). getLast har som formål å returnere verdien fra memcache, men ser til at den blir satt opp den ikke er satt. For å fylle opp id på Quote-objektet må jeg i tillegg bytte ut put-metoden til modellen.

def put(self):
self.id = memcache.incr("last")
if not self.id:
setLast()
self.id = memcache.incr("last")
return self.put()

Selv om jeg setter en id-verdi på objektet har objektet allerede en annen id som er tilgjengelig gjennom objekt.key().id(), og det er objektet fra objekt.key() som returneres ved put(). Den genererte id-en fra Google trenger følge på hverandre slik man gjerne opplever når man utvikler lokalt.

For å vise et gitt sitat er det ønskelig å benytte id-verdien som objektet automatisk har fått, og for å hente sitater ut gjør denne verdien det enkelt.

class View(Base):
def get(self, id):
quote = Quote.get_by_id(int(id))
if not quote:
raise Exception("Requested quote doesn't exists")
self.render("view.html", dict(quote=quote))

Quote.get_by_id() er en metode som gjør det veldig greit å hente et gitt objekt uten å måtte skrive en hel spørring. Dersom objektet som etterspørres ikke eksisterer er det ønskelig å lage et avvik, dette blir tatt hånd om av en metode i Base-klassen som er laget for å slippe å skrive mye kode:

class Base(webapp.RequestHandler):

def render(self, tpl, values = {}):
values["user"] = users.get_current_user()
values["url_login"] = users.create_login_url(self.request.url)
values["url_logout"] = users.create_logout_url("/")

self.response.out.write(
template.render("template/" + tpl, values)) # Lispy!

def handle_exception(self, exception, debug_mode):
self.response.out.write(
template.render("template/error.html", dict(error=exception)))

Denne klassen er laget kun for å slippe å skrive kode mange ganger (DRY). handle_excception tar imot avvik og lar meg håndtere disse på en fornuftig måte. render-metoden er en metode for å gjøre koden enklere, men også for å sikre at det blir sendt med noen ekstra variabler som link til innlogging og brukerinformasjon.

En av begrensningene til Datastore er at det mangler mulighet for å sortere i en tilfeldig rekkefølge (“SELECT … ORDER BY rand()”). Det er flere som har prøvd å løse denne mangelen, men siden jeg har laget meg en tilnærming til auto increment på tabellen må jeg klare å lage en tilfeldig verdi mellom den laveste og den høyeste mulige verdien.

class Front(Base):
def get(self):
rnd = random.randint(getFirst(), getLast())
quote = Quote.all().filter("id >= ", rnd).order("id").get()
if not quote:
quote = Quote.all().filter("id < ", rnd).order("id").get()
self.render("front.html", dict(quote=quote))

Den er muligens noe omfattende, men det er en tilnærming for å sikre at man alltid finner minst et sitat (så lenge det er noen i tabellen).

For å fortelle hvilke klasser som skal benyttes ved kall mot serveren må applikasjonen vite om disse, dette gjøres ved å legge inn informasjon om dette i filen;

application = webapp.WSGIApplication([
("/", Front),
("/add", Add),
("/view/(\d*)", View),
(".*", Error),
], debug=True)

def main():
run_wsgi_app(application)

if __name__ == "__main__":
main()

I tillegg må det være med en app.yaml som forteller enda litt til om applikasjonen:

application: rndquote
version: 1
runtime: python
api_version: 1

handlers:
- url: /style
static_dir: style

- url: /add
script: quote.py
login: required

- url: /admin.*
script: $PYTHON_LIB/google/appengine/ext/admin
login: admin

- url: /.*
script: quote.py

Det er verdt å merke seg at “login: required” gjør det at man må være innlogget for å få opp siden, hvilket er grunnen til at det ikke er noen kode for brukerhåndtering og annet i koden.

I tillegg til noen metoder og et par andre småting er applikasjonen ferdig, og den kan testes på rndquote.appspot.com. All nødvendig kildekode for å kjøre programmet kan lastes ned (må ha SDK i tillegg).

GAE er ikke kommet i endelig utgave enda, og det er satt en del begrensninger (maks 650 000 kall mot datastore og 2 500 000 sidekall per døgn), i tillegg er det enkelte ting som ikke er der som man normalt forventer å ha tilgjengelig når man utvikler for veven.

Til tross for begrensninger er det ingen tvil om at dette er gøy å leke med, og det er ikke vanskelig å se for seg en del ting som egner seg å lage for GAE.