Home Page Icon
Home Page
Table of Contents for
Programming Google App Engine
Close
Programming Google App Engine
by Dan Sanderson
Programming Google App Engine, 2nd Edition
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
Search in book...
Toggle Font Controls
Playlists
Add To
Create new playlist
Name your new playlist
Playlist description (optional)
Cancel
Create playlist
Sign In
Email address
Password
Forgot Password?
Create account
Login
or
Continue with Facebook
Continue with Google
Sign Up
Full Name
Email address
Confirm Email Address
Password
Login
Create account
or
Continue with Facebook
Continue with Google
Prev
Previous Chapter
Cover
Next
Next Chapter
Dedication
Programming Google App Engine
Dan Sanderson
Beijing • Cambridge • Farnham • Köln • Sebastopol • Tokyo
Add Highlight
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click
here
login for view all page.
Day Mode
Cloud Mode
Night Mode
Reset