You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
401 lines
15 KiB
401 lines
15 KiB
#!/usr/bin/python2.5
|
|
|
|
# Copyright (C) 2010 The Android Open Source Project
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may not
|
|
# use this file except in compliance with the License. You may obtain a copy of
|
|
# the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations under
|
|
# the License.
|
|
|
|
"""
|
|
Handlers for Sample SyncAdapter services.
|
|
|
|
Contains several RequestHandler subclasses used to handle post operations.
|
|
This script is designed to be run directly as a WSGI application.
|
|
|
|
"""
|
|
|
|
import cgi
|
|
import logging
|
|
import time as _time
|
|
from datetime import datetime
|
|
from django.utils import simplejson
|
|
from google.appengine.api import users
|
|
from google.appengine.ext import db
|
|
from google.appengine.ext import webapp
|
|
from model import datastore
|
|
import wsgiref.handlers
|
|
|
|
|
|
class BaseWebServiceHandler(webapp.RequestHandler):
|
|
"""
|
|
Base class for our web services. We put some common helper
|
|
functions here.
|
|
"""
|
|
|
|
"""
|
|
Since we're only simulating a single user account, declare our
|
|
hard-coded credentials here, so that they're easy to see/find.
|
|
We actually accept any and all usernames that start with this
|
|
hard-coded values. So if ACCT_USER_NAME is 'user', then we'll
|
|
accept 'user', 'user75', 'userbuddy', etc, all as legal account
|
|
usernames.
|
|
"""
|
|
ACCT_USER_NAME = 'user'
|
|
ACCT_PASSWORD = 'test'
|
|
ACCT_AUTH_TOKEN = 'xyzzy'
|
|
|
|
DATE_TIME_FORMAT = '%Y/%m/%d %H:%M'
|
|
|
|
"""
|
|
Process a request to authenticate a client. We assume that the username
|
|
and password will be included in the request. If successful, we'll return
|
|
an authtoken as the only content. If auth fails, we'll send an "invalid
|
|
credentials" error.
|
|
We return a boolean indicating whether we were successful (true) or not (false).
|
|
In the event that this call fails, we will setup the response, so callers just
|
|
need to RETURN in the error case.
|
|
"""
|
|
def authenticate(self):
|
|
self.username = self.request.get('username')
|
|
self.password = self.request.get('password')
|
|
|
|
logging.info('Authenticatng username: ' + self.username)
|
|
|
|
if ((self.username != None) and
|
|
(self.username.startswith(BaseWebServiceHandler.ACCT_USER_NAME)) and
|
|
(self.password == BaseWebServiceHandler.ACCT_PASSWORD)):
|
|
# Authentication was successful - return our hard-coded
|
|
# auth-token as the only response.
|
|
self.response.set_status(200, 'OK')
|
|
self.response.out.write(BaseWebServiceHandler.ACCT_AUTH_TOKEN)
|
|
return True
|
|
else:
|
|
# Authentication failed. Return the standard HTTP auth failure
|
|
# response to let the client know.
|
|
self.response.set_status(401, 'Invalid Credentials')
|
|
return False
|
|
|
|
"""
|
|
Validate the credentials of the client for a web service request.
|
|
The request should include username/password parameters that correspond
|
|
to our hard-coded single account values.
|
|
We return a boolean indicating whether we were successful (true) or not (false).
|
|
In the event that this call fails, we will setup the response, so callers just
|
|
need to RETURN in the error case.
|
|
"""
|
|
def validate(self):
|
|
self.username = self.request.get('username')
|
|
self.authtoken = self.request.get('authtoken')
|
|
|
|
logging.info('Validating username: ' + self.username)
|
|
|
|
if ((self.username != None) and
|
|
(self.username.startswith(BaseWebServiceHandler.ACCT_USER_NAME)) and
|
|
(self.authtoken == BaseWebServiceHandler.ACCT_AUTH_TOKEN)):
|
|
return True
|
|
else:
|
|
self.response.set_status(401, 'Invalid Credentials')
|
|
return False
|
|
|
|
|
|
class Authenticate(BaseWebServiceHandler):
|
|
"""
|
|
Handles requests for login and authentication.
|
|
|
|
UpdateHandler only accepts post events. It expects each
|
|
request to include username and password fields. It returns authtoken
|
|
after successful authentication and "invalid credentials" error otherwise.
|
|
"""
|
|
|
|
def post(self):
|
|
self.authenticate()
|
|
|
|
def get(self):
|
|
"""Used for debugging in a browser..."""
|
|
self.post()
|
|
|
|
|
|
class SyncContacts(BaseWebServiceHandler):
|
|
"""Handles requests for fetching user's contacts.
|
|
|
|
UpdateHandler only accepts post events. It expects each
|
|
request to include username and authtoken. If the authtoken is valid
|
|
it returns user's contact info in JSON format.
|
|
"""
|
|
|
|
def get(self):
|
|
"""Used for debugging in a browser..."""
|
|
self.post()
|
|
|
|
def post(self):
|
|
logging.info('*** Starting contact sync ***')
|
|
if (not self.validate()):
|
|
return
|
|
|
|
updated_contacts = []
|
|
|
|
# Process any client-side changes sent up in the request.
|
|
# Any new contacts that were added are included in the
|
|
# updated_contacts list, so that we return them to the
|
|
# client. That way, the client can see the serverId of
|
|
# the newly added contact.
|
|
client_buffer = self.request.get('contacts')
|
|
if ((client_buffer != None) and (client_buffer != '')):
|
|
self.process_client_changes(client_buffer, updated_contacts)
|
|
|
|
# Add any contacts that have been updated on the server-side
|
|
# since the last sync by this client.
|
|
client_state = self.request.get('syncstate')
|
|
self.get_updated_contacts(client_state, updated_contacts)
|
|
|
|
logging.info('Returning ' + str(len(updated_contacts)) + ' contact records')
|
|
|
|
# Return the list of updated contacts to the client
|
|
self.response.set_status(200)
|
|
self.response.out.write(toJSON(updated_contacts))
|
|
|
|
def get_updated_contacts(self, client_state, updated_contacts):
|
|
logging.info('* Processing server changes')
|
|
timestamp = None
|
|
|
|
base_url = self.request.host_url
|
|
|
|
# The client sends the last high-water-mark that they successfully
|
|
# sync'd to in the syncstate parameter. It's opaque to them, but
|
|
# its actually a seconds-in-unix-epoch timestamp that we use
|
|
# as a baseline.
|
|
if client_state:
|
|
logging.info('Client sync state: ' + client_state)
|
|
timestamp = datetime.utcfromtimestamp(float(client_state))
|
|
|
|
# Keep track of the update/delete counts, so we can log it
|
|
# below. Makes debugging easier...
|
|
update_count = 0
|
|
delete_count = 0
|
|
|
|
contacts = datastore.Contact.all()
|
|
if contacts:
|
|
# Find the high-water mark for the most recently updated friend.
|
|
# We'll return this as the syncstate (x) value for all the friends
|
|
# we return from this function.
|
|
high_water_date = datetime.min
|
|
for contact in contacts:
|
|
if (contact.updated > high_water_date):
|
|
high_water_date = contact.updated
|
|
high_water_mark = str(long(_time.mktime(high_water_date.utctimetuple())) + 1)
|
|
logging.info('New sync state: ' + high_water_mark)
|
|
|
|
# Now build the updated_contacts containing all the friends that have been
|
|
# changed since the last sync
|
|
for contact in contacts:
|
|
# If our list of contacts we're returning already contains this
|
|
# contact (for example, it's a contact just uploaded from the client)
|
|
# then don't bother processing it any further...
|
|
if (self.list_contains_contact(updated_contacts, contact)):
|
|
continue
|
|
|
|
handle = contact.handle
|
|
|
|
if timestamp is None or contact.updated > timestamp:
|
|
if contact.deleted == True:
|
|
delete_count = delete_count + 1
|
|
DeletedContactData(updated_contacts, handle, high_water_mark)
|
|
else:
|
|
update_count = update_count + 1
|
|
UpdatedContactData(updated_contacts, handle, None, base_url, high_water_mark)
|
|
|
|
logging.info('Server-side updates: ' + str(update_count))
|
|
logging.info('Server-side deletes: ' + str(delete_count))
|
|
|
|
def process_client_changes(self, contacts_buffer, updated_contacts):
|
|
logging.info('* Processing client changes: ' + self.username)
|
|
|
|
base_url = self.request.host_url
|
|
|
|
# Build an array of generic objects containing contact data,
|
|
# using the Django built-in JSON parser
|
|
logging.info('Uploaded contacts buffer: ' + contacts_buffer)
|
|
json_list = simplejson.loads(contacts_buffer)
|
|
logging.info('Client-side updates: ' + str(len(json_list)))
|
|
|
|
# Keep track of the number of new contacts the client sent to us,
|
|
# so that we can log it below.
|
|
new_contact_count = 0
|
|
|
|
for jcontact in json_list:
|
|
new_contact = False
|
|
id = self.safe_attr(jcontact, 'i')
|
|
if (id != None):
|
|
logging.info('Updating contact: ' + str(id))
|
|
contact = datastore.Contact.get(db.Key.from_path('Contact', id))
|
|
else:
|
|
logging.info('Creating new contact record')
|
|
new_contact = True
|
|
contact = datastore.Contact(handle='temp')
|
|
|
|
# If the 'change' for this contact is that they were deleted
|
|
# on the client-side, all we want to do is set the deleted
|
|
# flag here, and we're done.
|
|
if (self.safe_attr(jcontact, 'd') == True):
|
|
contact.deleted = True
|
|
contact.put()
|
|
logging.info('Deleted contact: ' + contact.handle)
|
|
continue
|
|
|
|
contact.firstname = self.safe_attr(jcontact, 'f')
|
|
contact.lastname = self.safe_attr(jcontact, 'l')
|
|
contact.phone_home = self.safe_attr(jcontact, 'h')
|
|
contact.phone_office = self.safe_attr(jcontact, 'o')
|
|
contact.phone_mobile = self.safe_attr(jcontact, 'm')
|
|
contact.email = self.safe_attr(jcontact, 'e')
|
|
contact.deleted = (self.safe_attr(jcontact, 'd') == 'true')
|
|
if (new_contact):
|
|
# New record - add them to db...
|
|
new_contact_count = new_contact_count + 1
|
|
contact.handle = contact.firstname + '_' + contact.lastname
|
|
logging.info('Created new contact handle: ' + contact.handle)
|
|
contact.put()
|
|
logging.info('Saved contact: ' + contact.handle)
|
|
|
|
# We don't save off the client_id value (thus we add it after
|
|
# the "put"), but we want it to be in the JSON object we
|
|
# serialize out, so that the client can match this contact
|
|
# up with the client version.
|
|
client_id = self.safe_attr(jcontact, 'c')
|
|
|
|
# Create a high-water-mark for sync-state from the 'updated' time
|
|
# for this contact, so we return the correct value to the client.
|
|
high_water = str(long(_time.mktime(contact.updated.utctimetuple())) + 1)
|
|
|
|
# Add new contacts to our updated_contacts, so that we return them
|
|
# to the client (so the client gets the serverId for the
|
|
# added contact)
|
|
if (new_contact):
|
|
UpdatedContactData(updated_contacts, contact.handle, client_id, base_url,
|
|
high_water)
|
|
|
|
logging.info('Client-side adds: ' + str(new_contact_count))
|
|
|
|
def list_contains_contact(self, contact_list, contact):
|
|
if (contact is None):
|
|
return False
|
|
contact_id = str(contact.key().id())
|
|
for next in contact_list:
|
|
if ((next != None) and (next['i'] == contact_id)):
|
|
return True
|
|
return False
|
|
|
|
def safe_attr(self, obj, attr_name):
|
|
if attr_name in obj:
|
|
return obj[attr_name]
|
|
return None
|
|
|
|
class ResetDatabase(BaseWebServiceHandler):
|
|
"""
|
|
Handles cron request to reset the contact database.
|
|
|
|
We have a weekly cron task that resets the database back to a
|
|
few contacts, so that it doesn't grow to an absurd size.
|
|
"""
|
|
|
|
def get(self):
|
|
# Delete all the existing contacts from the database
|
|
contacts = datastore.Contact.all()
|
|
for contact in contacts:
|
|
contact.delete()
|
|
|
|
# Now create three sample contacts
|
|
contact1 = datastore.Contact(handle = 'juliet',
|
|
firstname = 'Juliet',
|
|
lastname = 'Capulet',
|
|
phone_mobile = '(650) 555-1000',
|
|
phone_home = '(650) 555-1001',
|
|
status = 'Wherefore art thou Romeo?')
|
|
contact1.put()
|
|
|
|
contact2 = datastore.Contact(handle = 'romeo',
|
|
firstname = 'Romeo',
|
|
lastname = 'Montague',
|
|
phone_mobile = '(650) 555-2000',
|
|
phone_home = '(650) 555-2001',
|
|
status = 'I dream\'d a dream to-night')
|
|
contact2.put()
|
|
|
|
contact3 = datastore.Contact(handle = 'tybalt',
|
|
firstname = 'Tybalt',
|
|
lastname = 'Capulet',
|
|
phone_mobile = '(650) 555-3000',
|
|
phone_home = '(650) 555-3001',
|
|
status = 'Have at thee, coward')
|
|
contact3.put()
|
|
|
|
|
|
|
|
|
|
def toJSON(object):
|
|
"""Dumps the data represented by the object to JSON for wire transfer."""
|
|
return simplejson.dumps(object)
|
|
|
|
class UpdatedContactData(object):
|
|
"""Holds data for user's contacts.
|
|
|
|
This class knows how to serialize itself to JSON.
|
|
"""
|
|
__FIELD_MAP = {
|
|
'handle': 'u',
|
|
'firstname': 'f',
|
|
'lastname': 'l',
|
|
'status': 's',
|
|
'phone_home': 'h',
|
|
'phone_office': 'o',
|
|
'phone_mobile': 'm',
|
|
'email': 'e',
|
|
'client_id': 'c'
|
|
}
|
|
|
|
def __init__(self, contact_list, username, client_id, host_url, high_water_mark):
|
|
obj = datastore.Contact.get_contact_info(username)
|
|
contact = {}
|
|
for obj_name, json_name in self.__FIELD_MAP.items():
|
|
if hasattr(obj, obj_name):
|
|
v = getattr(obj, obj_name)
|
|
if (v != None):
|
|
contact[json_name] = str(v)
|
|
else:
|
|
contact[json_name] = None
|
|
contact['i'] = str(obj.key().id())
|
|
contact['a'] = host_url + "/avatar?id=" + str(obj.key().id())
|
|
contact['x'] = high_water_mark
|
|
if (client_id != None):
|
|
contact['c'] = str(client_id)
|
|
contact_list.append(contact)
|
|
|
|
class DeletedContactData(object):
|
|
def __init__(self, contact_list, username, high_water_mark):
|
|
obj = datastore.Contact.get_contact_info(username)
|
|
contact = {}
|
|
contact['d'] = 'true'
|
|
contact['i'] = str(obj.key().id())
|
|
contact['x'] = high_water_mark
|
|
contact_list.append(contact)
|
|
|
|
def main():
|
|
application = webapp.WSGIApplication(
|
|
[('/auth', Authenticate),
|
|
('/sync', SyncContacts),
|
|
('/reset_database', ResetDatabase),
|
|
],
|
|
debug=True)
|
|
wsgiref.handlers.CGIHandler().run(application)
|
|
|
|
if __name__ == "__main__":
|
|
main()
|