#!/usr/bin/env python # # Copyright 2007 Google Inc. # # 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. # """Stub version of the XMPP API, writes messages to logs.""" import logging import os from google.appengine.api import apiproxy_stub from google.appengine.api import app_identity from google.appengine.api.xmpp import xmpp_service_pb from google.appengine.runtime import apiproxy_errors INVALID_JID_CHARACTERS = ',;()[]' class XmppServiceStub(apiproxy_stub.APIProxyStub): """Python only xmpp service stub. This stub does not use an XMPP network. It prints messages to the console instead of sending any stanzas. """ THREADSAFE = True def __init__(self, log=logging.info, service_name='xmpp'): """Initializer. Args: log: A logger, used for dependency injection. service_name: Service name expected for all calls. """ super(XmppServiceStub, self).__init__(service_name) self.log = log def _Dynamic_GetPresence(self, request, response): """Implementation of XmppService::GetPresence. Returns online if the first character of the JID comes before 'm' in the alphabet, otherwise returns offline. Args: request: A PresenceRequest. response: A PresenceResponse. """ self._GetFrom(request.from_jid()) self._FillInPresenceResponse(request.jid(), response) def _Dynamic_BulkGetPresence(self, request, response): self._GetFrom(request.from_jid()) for jid in request.jid_list(): subresponse = response.add_presence_response() self._FillInPresenceResponse(jid, subresponse) def _FillInPresenceResponse(self, jid, response): """Arbitrarily fill in a presence response or subresponse.""" response.set_is_available(jid[0] < 'm') response.set_valid(self._ValidateJid(jid)) response.set_presence(1) def _Dynamic_SendMessage(self, request, response): """Implementation of XmppService::SendMessage. Args: request: An XmppMessageRequest. response: An XmppMessageResponse . """ from_jid = self._GetFrom(request.from_jid()) log_message = [] log_message.append('Sending an XMPP Message:') log_message.append(' From:') log_message.append(' ' + from_jid) log_message.append(' Body:') log_message.append(' ' + request.body()) log_message.append(' Type:') log_message.append(' ' + request.type()) log_message.append(' Raw Xml:') log_message.append(' ' + str(request.raw_xml())) log_message.append(' To JIDs:') for jid in request.jid_list(): log_message.append(' ' + jid) self.log('\n'.join(log_message)) for jid in request.jid_list(): if self._ValidateJid(jid): response.add_status(xmpp_service_pb.XmppMessageResponse.NO_ERROR) else: response.add_status(xmpp_service_pb.XmppMessageResponse.INVALID_JID) def _Dynamic_SendInvite(self, request, response): """Implementation of XmppService::SendInvite. Args: request: An XmppInviteRequest. response: An XmppInviteResponse . """ from_jid = self._GetFrom(request.from_jid()) self._ParseJid(request.jid()) log_message = [] log_message.append('Sending an XMPP Invite:') log_message.append(' From:') log_message.append(' ' + from_jid) log_message.append(' To: ' + request.jid()) self.log('\n'.join(log_message)) def _Dynamic_SendPresence(self, request, response): """Implementation of XmppService::SendPresence. Args: request: An XmppSendPresenceRequest. response: An XmppSendPresenceResponse . """ from_jid = self._GetFrom(request.from_jid()) log_message = [] log_message.append('Sending an XMPP Presence:') log_message.append(' From:') log_message.append(' ' + from_jid) log_message.append(' To: ' + request.jid()) if request.type(): log_message.append(' Type: ' + request.type()) if request.show(): log_message.append(' Show: ' + request.show()) if request.status(): log_message.append(' Status: ' + request.status()) self.log('\n'.join(log_message)) def _ParseJid(self, jid): """Parse the given JID. Also tests that the given jid: * Contains one and only one @. * Has one or zero resources. * Has a node. * Does not contain any invalid characters. Args: jid: The JID to validate Returns: A tuple (node, domain, resource) representing the JID. Raises: apiproxy_errors.ApplicationError if the requested JID is invalid using the criteria listed above. """ if set(jid).intersection(INVALID_JID_CHARACTERS): self.log('Invalid JID: characters "%s" not supported. JID: %s', INVALID_JID_CHARACTERS, jid) raise apiproxy_errors.ApplicationError( xmpp_service_pb.XmppServiceError.INVALID_JID) node, domain, resource = ('', '', '') at = jid.find('@') if at == -1: self.log('Invalid JID: No \'@\' character found. JID: %s', jid) raise apiproxy_errors.ApplicationError( xmpp_service_pb.XmppServiceError.INVALID_JID) node = jid[:at] if not node: self.log('Invalid JID: No node. JID: %s', jid) raise apiproxy_errors.ApplicationError( xmpp_service_pb.XmppServiceError.INVALID_JID) rest = jid[at+1:] if rest.find('@') > -1: self.log('Invalid JID: Second \'@\' character found. JID: %s', jid) raise apiproxy_errors.ApplicationError( xmpp_service_pb.XmppServiceError.INVALID_JID) slash = rest.find('/') if slash == -1: domain = rest resource = 'bot' else: domain = rest[:slash] resource = rest[slash+1:] if resource.find('/') > -1: self.log('Invalid JID: Second \'/\' character found. JID: %s', jid) raise apiproxy_errors.ApplicationError( xmpp_service_pb.XmppServiceError.INVALID_JID) return node, domain, resource def _ValidateJid(self, jid): """Validate the given JID using self._ParseJid.""" try: self._ParseJid(jid) return True except apiproxy_errors.ApplicationError: return False def _GetFrom(self, requested): """Validates that the from JID is valid. The JID uses the display-app-id for all apps to simulate a common case in production (alias === display-app-id). Args: requested: The requested from JID. Returns: string, The from JID. Raises: apiproxy_errors.ApplicationError if the requested JID is invalid. """ full_appid = os.environ.get('APPLICATION_ID') partition, _, display_app_id = ( app_identity.app_identity._ParseFullAppId(full_appid)) if requested == None or requested == '': return display_app_id + '@appspot.com/bot' node, domain, resource = self._ParseJid(requested) if domain == 'appspot.com' and node == display_app_id: return node + '@' + domain + '/' + resource elif domain == display_app_id + '.appspotchat.com': return node + '@' + domain + '/' + resource self.log('Invalid From JID: Must be appid@appspot.com[/resource] or ' 'node@appid.appspotchat.com[/resource]. JID: %s', requested) raise apiproxy_errors.ApplicationError( xmpp_service_pb.XmppServiceError.INVALID_JID) def _Dynamic_CreateChannel(self, request, response): """Implementation of XmppService::CreateChannel. Args: request: A CreateChannelRequest. response: A CreateChannelResponse. """ log_message = [] log_message.append('Sending a Create Channel:') log_message.append(' Client ID:') log_message.append(' ' + request.application_key()) if request.duration_minutes(): log_message.append(' Duration minutes: ' + str(request.duration_minutes())) self.log('\n'.join(log_message)) def _Dynamic_SendChannelMessage(self, request, response): """Implementation of XmppService::SendChannelMessage. Args: request: A SendMessageRequest. response: A SendMessageRequest. """ log_message = [] log_message.append('Sending a Channel Message:') log_message.append(' Client ID:') log_message.append(' ' + request.application_key()) log_message.append(' Message:') log_message.append(' ' + str(request.message())) self.log('\n'.join(log_message))