Programming Google App Engine by Sanderson, Dan -- Read -- Imperial Library of Trantor

Index

Programming Google App Engine Dedication Preface

Using This Book Conventions Used in This Book Using Code Samples Safari® Books Online How to Contact Us Acknowledgments

1. Introducing Google App Engine

The Runtime Environment The Static File Servers The Datastore

Entities and Properties Queries and Indexes Transactions

The Services Namespaces Google Accounts, OpenID, and OAuth Task Queues and Cron Jobs Developer Tools The Administration Console Things App Engine Doesn’t Do...Yet Getting Started

2. Creating an Application

Setting Up the SDK

Installing the Python SDK

A brief tour of the Launcher

Installing the Java SDK

Java on Mac OS X Installing the Java SDK with the Google Plugin for Eclipse Installing the Java SDK without Eclipse

Developing the Application

The User Preferences Pattern Developing a Python App

Introducing the webapp framework Users and Google Accounts Web forms and the datastore Caching with memcache

Developing a Java App

Introducing JSPs, JSTL, and EL Users and Google Accounts Web forms and the datastore Caching with memcache

The Development Console

The Python Interactive Console

Registering the Application

The Application ID and Title Setting Up a Domain Name Google Apps and Authentication

Uploading the Application

Using Two-Step Verification

Introducing the Administration Console

3. Configuring an Application

The App Engine Architecture Configuring a Python App

Runtime Versions

Configuring a Java App Domain Names App IDs and Versions

App IDs and Versions in Python App IDs and Versions in Java

Multithreading Request Handlers

Request Handlers in Python Request Handlers in Java

Static Files and Resource Files

Static Files in Python

MIME types Cache expiration

Static Files in Java

Secure Connections

Secure Connections in Python Secure Connections in Java

Authorization with Google Accounts

Authorization in Python Authorization in Java

Environment Variables Inbound Services Custom Error Responses Administration Console Custom Pages More Python Features

Python Libraries Built-in Handlers Includes

Java Servlet Sessions

4. Request Handlers and Instances

The Runtime Environment

The Sandbox Quotas and Limits

Request limits Service limits Deployment limits Billable quotas

The Python Runtime Environment The Java Runtime Environment

The Request Handler Abstraction Introducing Instances Request Scheduling and Pending Latency Warm-up Requests Resident Instances The Instances Console Instance Hours and Billing Instance Classes

5. Datastore Entities

Entities, Keys, and Properties Introducing the Python Datastore API Introducing the Java Datastore API Property Values

Strings, Text, and Blobs Unset Versus the Null Value Multivalued Properties

Keys and Key Objects Using Entities

Getting Entities Using Keys Inspecting Entity Objects Saving Entities Deleting Entities

Allocating System IDs The Development Server and the Datastore

6. Datastore Queries

Queries and Kinds Query Results and Keys GQL The Python Query API

The Query Class GQL in Python Retrieving Results Keys-Only Queries

The Java Query API

Building the Query Fetching Results with PreparedQuery Keys-Only Queries in Java

Introducing Indexes Automatic Indexes and Simple Queries

All Entities of a Kind One Equality Filter Greater-Than and Less-Than Filters One Sort Order Queries on Keys Kindless Queries

Custom Indexes and Complex Queries

Multiple Sort Orders Filters on Multiple Properties Multiple Equality Filters

Not-Equal and IN Filters Unset and Nonindexed Properties Sort Orders and Value Types Queries and Multivalued Properties

A Simple Example MVPs in Python MVPs in Java MVPs and Equality Filters MVPs and Inequality Filters MVPs and Sort Orders Exploding Indexes

Query Cursors

Cursors in Python Cursors in Java

Projection Queries

Projection Queries in Python Projection Queries in Java

Configuring Indexes

Index Configuration for Python Index Configuration for Java

7. Datastore Transactions

Entities and Entity Groups

Keys, Paths, and Ancestors Ancestor Queries

What Can Happen in a Transaction

Transactional Reads Eventually Consistent Reads

Transactions in Python Transactions in Java How Entities Are Updated How Entities Are Read Batch Updates How Indexes Are Updated Cross-Group Transactions

8. Datastore Administration

Inspecting the Datastore Managing Indexes The Datastore Admin Panel Accessing Metadata from the App

Querying Statistics Querying Metadata Index Status and Queries Entity Group Versions

Remote Controls

Setting Up the Remote API for Python Setting Up the Remote API for Java Using the Remote Shell Tool Using the Remote API from a Script

9. Data Modeling with Python

Models and Properties Property Declarations

Property Value Types Property Validation Nonindexed Properties Automatic Values List Properties Models and Schema Migration

Modeling Relationships

One-to-Many Relationships One-to-One Relationships Many-to-Many Relationships

The key list method The link model method

Model Inheritance Queries and PolyModels Creating Your Own Property Classes

Validating Property Values Marshaling Value Types Customizing Default Values Accepting Arguments

10. The Java Persistence API

Setting Up JPA Entities and Keys Entity Properties Embedded Objects Saving, Fetching, and Deleting Objects Transactions in JPA Queries and JPQL Relationships For More Information

11. The Memory Cache

Calling Memcache from Python Calling Memcache from Java Keys and Values Setting Values

Setting Values that Expire Adding and Replacing Values

Getting Values Deleting Values

Locking a Deleted Key

Atomic Increment and Decrement Compare and Set Batching Calls to Memcache

Memcache Batch Calls in Python Memcache Batch Calls in Java

Memcache and the Datastore Handling Memcache Errors Memcache Administration

Cache Statistics Flushing the Memcache

12. Large Data and the Blobstore

Accepting User Uploads

Web Forms and MIME Multipart Data Blobstore Upload Requests Handling Uploads in Python Handling Uploads in Java

Using BlobInfo Entities

Using BlobInfo Entities in Python Using BlobInfo Entities in Java

Serving Blobstore Values

Serving Blobstore Values in Python Serving Blobstore Values in Java

Deleting Blobstore Values Reading Blobstore Values

Fetching Byte Ranges Reading Values with Streams

A Complete Example

A Blobstore Example in Python A Blobstore Example in Java

13. Fetching URLs and Web Resources

Fetching URLs in Python Fetching URLs in Java Outgoing HTTP Requests

The URL The HTTP Method and Payload Request Headers

HTTP Over SSL (HTTPS) Request and Response Sizes Request Deadlines Handling Redirects Response Objects

14. Sending and Receiving Email Messages

Sending Email Messages

Sending Email from the Development Server Sender Addresses Recipients Attachments Sending Email in Python Sending Email in Java

Receiving Email Messages

Receiving Email in Python Receiving Email in Java

15. Sending and Receiving Instant Messages with XMPP

Inviting a User to Chat

Sending Invitations in Python Sending Invitations in Java

Sending Chat Messages

Sending Chat Messages in Python Sending Chat Messages in Java

Receiving Chat Messages

Receiving Chat Messages in Python

Handling Commands over Chat in Python

Receiving Chat Messages in Java

Handling Error Messages Managing Presence

Managing Subscriptions

Subscriptions in Python Subscriptions in Java

Managing Presence Updates

Presence in Python Presence in Java

Probing for Presence

Presence probes in Python Presence probes in Java

Checking a Google Talk User’s Status

16. Task Queues and Scheduled Tasks

Configuring Task Queues Enqueuing a Task

Enqueuing a Task in Python Enqueuing a Task in Java

Task Parameters

Payloads Task Names Countdowns and ETAs

Push Queues

Task Requests Processing Rates and Token Buckets Retrying Push Tasks

Pull Queues

Enqueuing Tasks to Pull Queues Leasing and Deleting Tasks Retrying Pull Queue Tasks

Transactional Task Enqueueing

Transactional Tasks in Python Transactional Tasks in Java

Task Chaining Task Queue Administration Deferring Work

Deferring Work in Python Deferring Work in Java

Scheduled Tasks

Configuring Scheduled Tasks Specifying Schedules

17. Optimizing Service Calls

Calling Services Asynchronously

Asynchronous Calls in Python

Datastore Memcache Blobstore URL Fetch Using callbacks

Asynchronous Calls in Java

Datastore Memcache URL Fetch

Visualizing Calls with AppStats

Installing AppStats for Python Installing AppStats for Java Using the AppStats Console

18. The Django Web Application Framework

Using the Bundled Django Library Creating a Django Project Hooking It Up to App Engine Creating a Django App Using Django Templates Using Django Forms The django-nonrel Project

19. Managing Request Logs

Writing to the Log

Logging in Python Logging in Java

Viewing Recent Logs Downloading Logs Logs Retention Querying Logs from the App

Querying Logs in Python Querying Logs in Java

Flushing the Log Buffer

20. Deploying and Managing Applications

Uploading an Application Using Versions Managing Service Configuration Application Settings Managing Developers Quotas and Billing Getting Help

Index About the Author Colophon Copyright

← Prev
Back
Next →

← Prev
Back
Next →