def CreateWsgiApplication(self): """Create WSGI application used on the server side for testing.""" return service.service_mappings([ ('/my/service', webapp_test_util.TestService), ('/my/other_service', webapp_test_util.TestService.new_factory('initialized')) ])
def __init__(self, api_services, **kwargs): """Initialize an _ApiServer instance. The primary function of this method is to set up the WSGIApplication instance for the service handlers described by the services passed in. Additionally, it registers each API in ApiConfigRegistry for later use in the BackendService.getApiConfigs() (API config enumeration service). Args: api_services: List of protorpc.remote.Service classes implementing the API **kwargs: Passed through to protorpc.wsgi.service.service_handlers except: protocols - ProtoRPC protocols are not supported, and are disallowed. restricted - If True or unset, the API will only be allowed to serve to Google's API serving infrastructure once deployed. Set to False to allow other clients. Under dev_appserver, all clients are accepted. NOTE! Under experimental launch, this is not a secure restriction and other authentication mechanisms *must* be used to control access to the API. The restriction is only intended to notify developers of a possible upcoming feature to securely restrict access to the API. Raises: TypeError: if protocols are configured (this feature is not supported). ApiConfigurationError: if there's a problem with the API config. """ protorpc_services = [] generator = api_config.ApiConfigGenerator() self.api_config_registry = api_backend_service.ApiConfigRegistry() api_name_version_map = {} for service in api_services: key = (service.api_info.name, service.api_info.version) services = api_name_version_map.setdefault(key, []) if service in services: raise api_config.ApiConfigurationError( 'Can\'t add the same class to an API twice: %s' % service.__name__) services.append(service) for services in api_name_version_map.values(): config_file = generator.pretty_print_config_to_json(services) self.api_config_registry.register_spi(config_file) for api_service in services: protorpc_class_name = api_service.__name__ root = self.__SPI_PREFIX + protorpc_class_name if not any(service[0] == root or service[1] == api_service for service in protorpc_services): protorpc_services.append((root, api_service)) backend_service = api_backend_service.BackendServiceImpl.new_factory( self.api_config_registry, _get_app_revision()) protorpc_services.insert(0, (self.__BACKEND_SERVICE_ROOT, backend_service)) if 'protocols' in kwargs: raise TypeError('__init__() got an unexpected keyword argument ' "'protocols'") self.restricted = kwargs.pop('restricted', True) self.service_app = wsgi_service.service_mappings(protorpc_services, **kwargs)
def CreateWsgiApplication(self): """Create WSGI application used on the server side for testing.""" return service.service_mappings( [('/my/service', webapp_test_util.TestService), ('/my/other_service', webapp_test_util.TestService.new_factory('initialized')) ])
def __init__(self, api_services, **kwargs): """Initialize an _ApiServer instance. The primary function of this method is to set up the WSGIApplication instance for the service handlers described by the services passed in. Additionally, it registers each API in ApiConfigRegistry for later use in the BackendService.getApiConfigs() (API config enumeration service). Args: api_services: List of protorpc.remote.Service classes implementing the API **kwargs: Passed through to protorpc.wsgi.service.service_handlers except: protocols - ProtoRPC protocols are not supported, and are disallowed. restricted - If True or unset, the API will only be allowed to serve to Google's API serving infrastructure once deployed. Set to False to allow other clients. Under dev_appserver, all clients are accepted. NOTE! Under experimental launch, this is not a secure restriction and other authentication mechanisms *must* be used to control access to the API. The restriction is only intended to notify developers of a possible upcoming feature to securely restrict access to the API. Raises: TypeError: if protocols are configured (this feature is not supported). ApiConfigurationError: if there's a problem with the API config. """ protorpc_services = [] generator = api_config.ApiConfigGenerator() self.api_config_registry = api_backend_service.ApiConfigRegistry() api_name_version_map = {} for service in api_services: key = (service.api_info.name, service.api_info.version) services = api_name_version_map.setdefault(key, []) if service in services: raise api_config.ApiConfigurationError( 'Can\'t add the same class to an API twice: %s' % service.__name__) services.append(service) for services in api_name_version_map.values(): config_file = generator.pretty_print_config_to_json(services) self.api_config_registry.register_spi(config_file) for api_service in services: protorpc_class_name = api_service.__name__ root = self.__SPI_PREFIX + protorpc_class_name if not any(service[0] == root or service[1] == api_service for service in protorpc_services): protorpc_services.append((root, api_service)) backend_service = api_backend_service.BackendServiceImpl.new_factory( self.api_config_registry, _get_app_revision()) protorpc_services.insert( 0, (self.__BACKEND_SERVICE_ROOT, backend_service)) if 'protocols' in kwargs: raise TypeError('__init__() got an unexpected keyword argument ' "'protocols'") self.restricted = kwargs.pop('restricted', True) self.service_app = wsgi_service.service_mappings( protorpc_services, **kwargs)
def testNoRegistry(self): self.ResetServer( service.service_mappings( [('/my/service', webapp_test_util.TestService), ('/my/other_service', webapp_test_util.TestService.new_factory('initialized'))], registry_path=None)) registry_client = self.GetRegistryStub() self.assertRaisesWithRegexpMatch(remote.ServerError, 'HTTP Error 404: Not Found', registry_client.services)
def __init__(self, api_services, **kwargs): """Initialize an _ApiServer instance. The primary function of this method is to set up the WSGIApplication instance for the service handlers described by the services passed in. Additionally, it registers each API in ApiConfigRegistry for later use in the BackendService.getApiConfigs() (API config enumeration service). Args: api_services: List of protorpc.remote.Service classes implementing the API or a list of _ApiDecorator instances that decorate the service classes for an API. **kwargs: Passed through to protorpc.wsgi.service.service_handlers except: protocols - ProtoRPC protocols are not supported, and are disallowed. Raises: TypeError: if protocols are configured (this feature is not supported). ApiConfigurationError: if there's a problem with the API config. """ self.base_paths = set() for entry in api_services[:]: # pylint: disable=protected-access if isinstance(entry, api_config._ApiDecorator): api_services.remove(entry) api_services.extend(entry.get_api_classes()) self.base_paths.add(entry.base_path) # Record the API services for quick discovery doc generation self.api_services = api_services # Record the base paths for entry in api_services: self.base_paths.add(entry.api_info.base_path) self.api_config_registry = api_backend_service.ApiConfigRegistry() self.api_name_version_map = self.__create_name_version_map(api_services) protorpc_services = self.__register_services(self.api_name_version_map, self.api_config_registry) # Disallow protocol configuration for now, Lily is json-only. if 'protocols' in kwargs: raise TypeError('__init__() got an unexpected keyword argument ' "'protocols'") protocols = remote.Protocols() protocols.add_protocol(self.__PROTOJSON, 'protojson') remote.Protocols.set_default(protocols) # This variable is not used in Endpoints 1.1, but let's pop it out here # so it doesn't result in an unexpected keyword argument downstream. kwargs.pop('restricted', None) self.service_app = wsgi_service.service_mappings(protorpc_services, **kwargs)
def __init__(self, api_services, **kwargs): """Initialize an _ApiServer instance. The primary function of this method is to set up the WSGIApplication instance for the service handlers described by the services passed in. Additionally, it registers each API in ApiConfigRegistry for later use in the BackendService.getApiConfigs() (API config enumeration service). Args: api_services: List of protorpc.remote.Service classes implementing the API or a list of _ApiDecorator instances that decorate the service classes for an API. **kwargs: Passed through to protorpc.wsgi.service.service_handlers except: protocols - ProtoRPC protocols are not supported, and are disallowed. restricted - If True or unset, the API will only be allowed to serve to Google's API serving infrastructure once deployed. Set to False to allow other clients. Under dev_appserver, all clients are accepted. NOTE! Under experimental launch, this is not a secure restriction and other authentication mechanisms *must* be used to control access to the API. The restriction is only intended to notify developers of a possible upcoming feature to securely restrict access to the API. Raises: TypeError: if protocols are configured (this feature is not supported). ApiConfigurationError: if there's a problem with the API config. """ for entry in api_services[:]: if isinstance(entry, api_config._ApiDecorator): api_services.remove(entry) api_services.extend(entry.get_api_classes()) self.api_config_registry = api_backend_service.ApiConfigRegistry() api_name_version_map = self.__create_name_version_map(api_services) protorpc_services = self.__register_services(api_name_version_map, self.api_config_registry) backend_service = api_backend_service.BackendServiceImpl.new_factory( self.api_config_registry, _get_app_revision()) protorpc_services.insert(0, (self.__BACKEND_SERVICE_ROOT, backend_service)) if 'protocols' in kwargs: raise TypeError('__init__() got an unexpected keyword argument ' "'protocols'") protocols = remote.Protocols() protocols.add_protocol(self.__PROTOJSON, 'protojson') remote.Protocols.set_default(protocols) self.restricted = kwargs.pop('restricted', True) self.service_app = wsgi_service.service_mappings(protorpc_services, **kwargs)
def testNoRegistry(self): self.ResetServer(service.service_mappings( [('/my/service', webapp_test_util.TestService), ('/my/other_service', webapp_test_util.TestService.new_factory('initialized')) ], registry_path=None)) registry_client = self.GetRegistryStub() self.assertRaisesWithRegexpMatch( remote.ServerError, 'HTTP Error 404: Not Found', registry_client.services)
def api_server(api_services): """Set up an WSGIApplication instance for the API services provided. https://github.com/cloudendpoints/endpoints-python/blob/9da60817aefbb0f2a4b9145c17ee39b9115067b0/endpoints/apiserving.py#L541 """ services = [] for service_class in api_services: service_path = '{}{}/{}'.format(service_class.wrapper_api_base_path, service_class.wrapper_api_name, service_class.wrapper_api_version) services.append((service_path, service_class)) return service.service_mappings(services)
def application(environ, start_response): urlfetch.set_default_fetch_deadline(60) import_services() response = None if environ.get('REQUEST_METHOD') in ["OPTIONS"]: start_response('200 OK', [('Access-Control-Allow-Headers', 'authorization, origin, content-type, accept'), ('Access-Control-Max-Age', '600'), ('Access-Control-Allow-Origin', '*')]) response = [''] elif environ.get('REQUEST_METHOD') in ["GET", "HEAD", "POST"]: swagger = swagger2(environ.get('HTTP_HOST'), environ.get('PATH_INFO')) if swagger: start_response('200 OK', [('Content-type', 'application/json'), ('Access-Control-Allow-Origin', '*')]) response = [swagger] else: app = service.service_mappings([(s.path, s) for s in SERVICES], registry_path=None) query = dict(urlparse.parse_qsl(environ.get('QUERY_STRING'))) if environ.get('REQUEST_METHOD') in [ "GET", "HEAD" ] and environ.get('QUERY_STRING'): content = json.dumps(query) environ['wsgi.input'] = StringIO.StringIO(content) environ['CONTENT_LENGTH'] = len(content) environ['REQUEST_METHOD'] = 'POST' environ['CONTENT_TYPE'] = 'application/json' if environ.get('HTTP_AUTHORIZATION') is None and query.get( "authorization") is not None: environ['HTTP_AUTHORIZATION'] = query.get("authorization") def _start_response(status, response_headers): response_headers.append(('Access-Control-Allow-Origin', '*')) return start_response(status, response_headers) response = app(environ, _start_response) else: start_response('405 Method Not Allowed', [('Allow', 'OPTIONS, GET, HEAD, POST')]) response = [''] if environ.get('REQUEST_METHOD') in ["HEAD"]: return [''] else: return response
def CreateWSGIApplication(pod=None): podserver_app = webapp2.WSGIApplication([ ('/.*', handlers.PodHandler), ]) podserver_app.registry['pod'] = pod routes = [ ('/_api/pods.*', services.PodService), ] return service.service_mappings( routes, service_prefix='/_api', registry_path='/_api/protorpc', append_wsgi_apps=[podserver_app])
def testRegistryDictionary(self): self.ResetServer(service.service_mappings( {'/my/service': webapp_test_util.TestService, '/my/other_service': webapp_test_util.TestService.new_factory('initialized'), })) registry_client = self.GetRegistryStub() response = registry_client.services() self.assertIterEqual([ registry.ServiceMapping( name='/my/other_service', definition='protorpc.webapp_test_util.TestService'), registry.ServiceMapping( name='/my/service', definition='protorpc.webapp_test_util.TestService'), ], response.services)
def testRegistryDictionary(self): self.ResetServer( service.service_mappings({ '/my/service': webapp_test_util.TestService, '/my/other_service': webapp_test_util.TestService.new_factory('initialized'), })) registry_client = self.GetRegistryStub() response = registry_client.services() self.assertIterEqual([ registry.ServiceMapping( name='/my/other_service', definition='protorpc.webapp_test_util.TestService'), registry.ServiceMapping( name='/my/service', definition='protorpc.webapp_test_util.TestService'), ], response.services)
def testAltRegistry(self): self.ResetServer( service.service_mappings( [('/my/service', webapp_test_util.TestService), ('/my/other_service', webapp_test_util.TestService.new_factory('initialized'))], registry_path='/registry')) registry_client = self.GetRegistryStub('/registry') services = registry_client.services() self.assertTrue(isinstance(services, registry.ServicesResponse)) self.assertIterEqual([ registry.ServiceMapping( name='/my/other_service', definition='protorpc.webapp_test_util.TestService'), registry.ServiceMapping( name='/my/service', definition='protorpc.webapp_test_util.TestService'), ], services.services)
def CreateWSGIApplication(pod=None, debug=False): podserver_app = WSGIApplication([ ('/_grow/translations/(.*)', handlers.CatalogHandler), ('/_grow/translations', handlers.CatalogsHandler), ('/_grow/content', handlers.CollectionsHandler), ('/_grow', handlers.ConsoleHandler), ('/.*', handlers.PodHandler), ], debug=debug) podserver_app.registry['pod'] = pod api_routes = [] api_app = service.service_mappings( api_routes, service_prefix='/_api', registry_path='/_api/protorpc', append_wsgi_apps=[podserver_app]) static_path = os.path.join(utils.get_grow_dir(), 'server', 'frontend') return wsgi.SharedDataMiddleware(api_app, { '/_grow/static': static_path, })
def testRegex(self): self.ResetServer(service.service_mappings( [('/my/[0-9]+', webapp_test_util.TestService.new_factory('service')), ('/my/[a-z]+', webapp_test_util.TestService.new_factory('other-service')), ])) my_service_url = 'http://localhost:%d/my/12345' % self.port my_other_service_url = 'http://localhost:%d/my/blarblar' % self.port my_service = webapp_test_util.TestService.Stub( transport.HttpTransport(my_service_url)) my_other_service = webapp_test_util.TestService.Stub( transport.HttpTransport(my_other_service_url)) response = my_service.init_parameter() self.assertEquals('service', response.string_value) response = my_other_service.init_parameter() self.assertEquals('other-service', response.string_value)
def testAltRegistry(self): self.ResetServer(service.service_mappings( [('/my/service', webapp_test_util.TestService), ('/my/other_service', webapp_test_util.TestService.new_factory('initialized')) ], registry_path='/registry')) registry_client = self.GetRegistryStub('/registry') services = registry_client.services() self.assertTrue(isinstance(services, registry.ServicesResponse)) self.assertIterEqual( [registry.ServiceMapping( name='/my/other_service', definition='protorpc.webapp_test_util.TestService'), registry.ServiceMapping( name='/my/service', definition='protorpc.webapp_test_util.TestService'), ], services.services)
def testRegex(self): self.ResetServer( service.service_mappings([ ('/my/[0-9]+', webapp_test_util.TestService.new_factory('service')), ('/my/[a-z]+', webapp_test_util.TestService.new_factory('other-service')), ])) my_service_url = 'http://localhost:%d/my/12345' % self.port my_other_service_url = 'http://localhost:%d/my/blarblar' % self.port my_service = webapp_test_util.TestService.Stub( transport.HttpTransport(my_service_url)) my_other_service = webapp_test_util.TestService.Stub( transport.HttpTransport(my_other_service_url)) response = my_service.init_parameter() self.assertEquals('service', response.string_value) response = my_other_service.init_parameter() self.assertEquals('other-service', response.string_value)
from protorpc import messages from protorpc import remote from protorpc.wsgi import service from team import Team import logging package = 'SaintsSchedule' # Create the request string containing the user's name class ScheduleRequest(messages.Message): team_id = messages.StringField(1, required=True) # Create the response string class ScheduleResponse(messages.Message): schedule = messages.StringField(1, required=True) # Create the RPC service to exchange messages class ScheduleService(remote.Service): @remote.method(ScheduleRequest, ScheduleResponse) def schedule(self, request): t = Team() games = t.getGames(request.team_id) return ScheduleResponse(schedule=games) # Map the RPC service and path (/schedule) app = service.service_mappings([('/schedule.*', ScheduleService)])
from protorpc.wsgi import service import archiveservice # Map the RPC service and path (/ArchiveService) app = service.service_mappings([('/ArchiveService', archiveservice.ArchiveService)])
class SeasonRequest(messages.Message): seasonRequest = messages.StringField(1, required=False) # Create the response string class SeasonResponse(messages.Message): seasons = messages.MessageField(Season, 1, repeated=True) # Create the RPC service to exchange messages class SeasonService(remote.Service): @remote.method(SeasonRequest, SeasonResponse) def season(self, request): theCache = memcache.get("seasons") if theCache is None: t = Team() seasons = [] for team in t.getSeasons(): season = Season(season=team.season) if season not in seasons: seasons.append(season) if not memcache.add("seasons", seasons): logging.error("memcache failed to set") return SeasonResponse(seasons=seasons) else: return SeasonResponse(seasons=theCache) # Map the RPC service and path (/schedule) app = service.service_mappings([("/season.*", SeasonService)])
from protorpc.wsgi import service as wsgi_service from api import maps service = wsgi_service.service_mappings([ ('/api/maps', maps.PostService), ])
from protorpc import remote from protorpc.wsgi import service class IncrementLapRequest(messages.Message): """Request to increment the lap count.""" barcode_number = messages.IntegerField(1) increment_by = messages.IntegerField(2, default=1) validate = messages.BooleanField(3, default=True) class IncrementLapResponse(messages.Message): """Response from incrementing lap count.""" student_last_name = messages.StringField(1) student_first_name = messages.StringField(2) student_photo_url = messages.StringField(3) lap_count = messages.IntegerField(4) # Create the RPC service that handles barcodes. class BarcodesService(utils.CaminataService): """RPC service that handles barcodes.""" @remote.method(IncrementLapRequest, IncrementLapResponse) def increment_lap_count(self, request): return IncrementLapResponse(student_last_name='Foo') # Map the RPC service. app = service.service_mappings([('/barcodes', BarcodesService)])
from protorpc.wsgi import service from REST import mpg_service app = service.service_mappings([('/REST/mpg_service', mpg_service.PostService)])
location = messages.StringField(5, required=True) game_id = messages.StringField(6, required=True) score = messages.StringField(7) class GamesRequest(messages.Message): team_id = messages.StringField(1, required=True) # Create the response string class GamesResponse(messages.Message): games = messages.MessageField(Games, 1, repeated=True) # Create the RPC service to exchange messages class GamesService(remote.Service): @remote.method(GamesRequest, GamesResponse) def games(self, request): t = Team() responseArray = [] schedule = t.getGames(request.team_id) trimmedSchedule = schedule[10:len(schedule)-1] gamesArray = eval(trimmedSchedule) for game in gamesArray: logging.info(game) responseGame = Games(game_date=game['game_date'][5:], time=game['time'], home=game['home'], away=game['away'], location=game['location'], game_id=game['id'], score=game['score']) responseArray.append(responseGame) return GamesResponse(games=responseArray) # Map the RPC service and path (/schedule) app = service.service_mappings([('/games.*', GamesService)])
class SeasonRequest(messages.Message): seasonRequest = messages.StringField(1, required=False) # Create the response string class SeasonResponse(messages.Message): seasons = messages.MessageField(Season, 1, repeated=True) # Create the RPC service to exchange messages class SeasonService(remote.Service): @remote.method(SeasonRequest, SeasonResponse) def season(self, request): theCache = memcache.get('seasons') if theCache is None: t = Team() seasons = [] for team in t.getSeasons(): season = Season(season=team.season) if season not in seasons: seasons.append(season) if not memcache.add('seasons', seasons): logging.error('memcache failed to set') return SeasonResponse(seasons=seasons) else: return SeasonResponse(seasons=theCache) # Map the RPC service and path (/schedule) app = service.service_mappings([('/season.*', SeasonService)])
if problem.type == gemmate_model.Problem.FEASIBLE_HULL and problem.upper_bound > tree_bound: # create cyclic problem cyclic_problem_id = problem.hull + "_" + str(gemmate_model.Problem.CYCLIC) cyclic_problem = gemmate_model.Problem(hull=problem.hull, type=gemmate_model.Problem.CYCLIC,id=cyclic_problem_id,solved=False,parent=problem.key.parent()) logging.info("Generating new CYCLIC problem with Id " + cyclic_problem_id) updated_problems_list.append(cyclic_problem) if problem.type == gemmate_model.Problem.CYCLIC and problem.upper_bound > tree_bound: # create regular problem regular_problem_id = problem.hull + "_" + str(gemmate_model.Problem.REGULAR) regular_problem = gemmate_model.Problem(hull=problem.hull, type=gemmate_model.Problem.REGULAR,id=regular_problem_id,solved=False,parent=problem.key.parent()) logging.info("Generating new REGULAR problem with Id " + regular_problem_id) updated_problems_list.append(regular_problem) elif request.solution_type == "CUTOFF": problem.upper_bound = request.upper_bound problem.solution_type = "CUTOFF" else: problem.solution_type = "INFEASIBLE" updated_problems_list.append(problem) ndb.put_multi(updated_problems_list) return message_types.VoidMessage() app = service.service_mappings([ ('/ProblemDB.*', ProblemDB) ])
# Create the response string class SchoolResponse(messages.Message): schools = messages.MessageField(School, 1, repeated=True) # Create the RPC service to exchange messages class SchoolService(remote.Service): @remote.method(SchoolRequest, SchoolResponse) def school(self, request): cacheKey = request.season if cacheKey is None: cacheKey = 'AllSchools' theCache = memcache.get(cacheKey) if theCache is None: t = Team() schools = [] for team in t.getSchools(request.season): school = School(school=team.school) if school not in schools: schools.append(school) if not memcache.add(cacheKey, schools): logging.error('Unable to set cache') return SchoolResponse(schools=schools) else: return SchoolResponse(schools=theCache) # Map the RPC service and path (/schedule) app = service.service_mappings([('/school.*', SchoolService)])
from protorpc import messages from protorpc import remote from protorpc.wsgi import service package = 'hello' # Create the request string containing the user's name class HelloRequest(messages.Message): my_name = messages.StringField(1, required=True) # Create the response string class HelloResponse(messages.Message): hello = messages.StringField(1, required=True) # Create the RPC service to exchange messages class HelloService(remote.Service): @remote.method(HelloRequest, HelloResponse) def hello(self, request): return HelloResponse(hello='Hello there, %s!' % request.my_name) # Map the RPC service and path (/hello) app = service.service_mappings([('/hello.*', HelloService)])
class MovieFetcherRequest(messages.Message): # pragma: no cover api_key = messages.StringField(1, required=True) omdb_start_id = messages.StringField(2, required=False) nof_movies = messages.IntegerField(3, required=False) class MovieFetcherResponse(messages.Message): # pragma: no cover result = messages.StringField(1, required=True) class MovieFetcherService(remote.Service): # pragma: no cover @remote.method(MovieFetcherRequest, MovieFetcherResponse) def fetch(self, request): # Use default start id if it is not supplied in the request start_id = request.omdb_start_id if request.omdb_start_id else DEFAULT_OMDB_ID # Use default number of movies if it is not supplied in the request nof_movies = request.nof_movies if request.nof_movies else DEFAULT_NOF_MOVIES moviefetcher = MovieFetcher() success = moviefetcher.get_movies_by_id(request.api_key, start_id, nof_movies) return MovieFetcherResponse( result=SUCCESS_MSG if success else FAILURE_MSG) # Map the RPC service and path (/MovieFetcher.fetch) app = service.service_mappings([('/MovieFetcher.*', MovieFetcherService)])
return TBANSResponse(code=response.status_code, message=response.content) elif request.webhook: from tbans.models.requests.notifications.webhook_request import WebhookRequest webhook_request = WebhookRequest(notification, request.webhook.url, request.webhook.secret) logging.info('Ping - {}'.format(str(webhook_request))) response = webhook_request.send() logging.info('Ping Response - {}'.format(str(response))) return TBANSResponse(code=response.status_code, message=response.content) else: return self._application_error('Did not specify FCM or webhook to ping') @remote.method(VerificationRequest, VerificationResponse) def verification(self, request): """ Immediately dispatch a Verification to a webhook """ self._validate_authentication() from tbans.models.notifications.verification import VerificationNotification notification = VerificationNotification(request.webhook.url, request.webhook.secret) from tbans.models.requests.notifications.webhook_request import WebhookRequest webhook_request = WebhookRequest(notification, request.webhook.url, request.webhook.secret) logging.info('Verification - {}'.format(str(webhook_request))) response = webhook_request.send() logging.info('Verification Response - {}'.format(str(response))) return VerificationResponse(code=response.status_code, message=response.content, verification_key=notification.verification_key) app = service.service_mappings([('/tbans.*', TBANSService)])
from protorpc.wsgi import service import postservice app = service.service_mappings([('/PostService', postservice.PostService)])
@remote.method(StartedEventMessage, StartedEventMessage) def delete(self, request): Key(urlsafe=request.id).delete() return request def transformStartedEventToEvent(self, startedEventMessage, endTime): self.delete(startedEventMessage) event = Event( actor=users.get_current_user(), activityCode=(startedEventMessage.activityCode), #comment = (startedEventMessage.comment), startTime=parseMsgTime(startedEventMessage.startTime), endTime=parseMsgTime(endTime), value=startedEventMessage.eventValue) event.put() return eventToMessage(event) @remote.method(CompleteStartedEventMessage, EventMessage) def complete(self, request): return ndb.transaction(lambda: self.transformStartedEventToEvent( request.startedEvent, request.endTime), xg=True) app = service.service_mappings([ ('/service/event', EventService), ('/service/settings', SettingsService), ('/service/activity', ActivityService), ('/service/reportRequest', ReportRequestService), ('/service/startedEvents', StartedEventService) ])
''' Created on Nov 12, 2014 @author: alantai ''' from protorpc import messages, remote from protorpc.wsgi import service class MessageRequest(messages.Message): my_message = messages.StringField(1, required = True) class MessageResponse(messages.Message): my_response = messages.StringField(1, required = True) class MessageService(remote.Service): @remote.method(MessageRequest, MessageResponse) def handle_message(self, request): return MessageResponse( my_message = "The message is: {my_message}".format("my_message", request.my_message)) app = service.service_mappings([('/protortc/message_service/test', MessageService)])
# Create the request string containing the user's name class CoachRequest(messages.Message): school = messages.StringField(1, required=False) season = messages.StringField(2, required=False) # Create the RPC service to exchange messages class CoachService(remote.Service): @remote.method(CoachRequest, Coaches) def coach(self, request): cacheKey = 'AllCoaches' if (request.school is not None) and (request.season is None): cacheKey = request.school else: cacheKey = request.season + request.school theCache = memcache.get(cacheKey) if theCache is None: t = Team() coaches = [] for team in t.getCoaches(request.school, request.season): coach = Coach(team_id=team.teamId, name=team.coach, school=team.school, grade=team.grade) coaches.append(coach) if not memcache.add(cacheKey, coaches): logging.error('Unable to set cache') return Coaches(coaches=coaches) else: return Coaches(coaches=theCache) # Map the RPC service and path (/schedule) app = service.service_mappings([('/coach.*', CoachService)])
season = messages.StringField(1, required=False) # Create the response string class SchoolResponse(messages.Message): schools = messages.MessageField(School, 1, repeated=True) # Create the RPC service to exchange messages class SchoolService(remote.Service): @remote.method(SchoolRequest, SchoolResponse) def school(self, request): cacheKey = request.season if cacheKey is None: cacheKey = 'AllSchools' theCache = memcache.get(cacheKey) if theCache is None: t = Team() schools = [] for team in t.getSchools(request.season): school = School(school=team.school) if school not in schools: schools.append(school) if not memcache.add(cacheKey, schools): logging.error('Unable to set cache') return SchoolResponse(schools=schools) else: return SchoolResponse(schools=theCache) # Map the RPC service and path (/schedule) app = service.service_mappings([('/school.*', SchoolService)])
#!/usr/bin/python try: from grow import submodules submodules.fix_imports() except ImportError: pass import webapp2 from protorpc.wsgi import service from grow.server import handlers from grow.server import services podserver_app = webapp2.WSGIApplication([ ('/.*', handlers.PodHandler), ]) routes = [ ('/_api/pods.*', services.PodService), ] application = service.service_mappings( routes, service_prefix='/_api', registry_path='/_api/protorpc', append_wsgi_apps=[podserver_app])
# -*- coding: UTF-8 -*- import logging logger = logging.getLogger(__name__) import traceback from protorpc.wsgi import service from protorpc.webapp import forms from . import test_service from . import playswith_page_service from . import project_service package = "org.angularjs.playswith" mapping = [ ("/rpc/test", test_service.TestService), ("/rpc/project", project_service.ProjectService), ("/rpc/playswith_page", playswith_page_service.PlayswithPageService), ] app = service.service_mappings(mapping, registry_path="/protorpc")
def delete(self, request): Key(urlsafe = request.id).delete() return request def transformStartedEventToEvent(self, startedEventMessage, endTime): self.delete(startedEventMessage) event = Event( actor = users.get_current_user(), activityCode = (startedEventMessage.activityCode), #comment = (startedEventMessage.comment), startTime = parseMsgTime(startedEventMessage.startTime), endTime = parseMsgTime(endTime), value = startedEventMessage.eventValue) event.put() return eventToMessage(event) @remote.method(CompleteStartedEventMessage, EventMessage) def complete(self, request): return ndb.transaction(lambda : self.transformStartedEventToEvent(request.startedEvent, request.endTime), xg=True) app = service.service_mappings( [('/service/event', EventService), ('/service/settings', SettingsService), ('/service/activity', ActivityService), ('/service/reportRequest', ReportRequestService), ('/service/startedEvents', StartedEventService)])
auth_app = webapp2.WSGIApplication([ # ('/auth/signin/start', auth_handlers.SignInHandler), # ('/auth/signin/callback', auth_handlers.SignInCallbackHandler), # ('/auth/sign_in', auth_handlers.SignInHandler), ], config=config.WEBAPP2_AUTH_CONFIG) oauth2_app = webapp2.WSGIApplication([ ('/oauth2callback', auth_handlers.OAuth2CallbackHandler), ], config=config.WEBAPP2_AUTH_CONFIG) api_app = service.service_mappings(( ('/_api/avatars.*', avatar_services.AvatarService), ('/_api/filesets.*', fileset_services.FilesetService), ('/_api/me.*', user_services.MeService), ('/_api/owners.*', owner_services.OwnerService), ('/_api/orgs.*', org_services.OrgService), ('/_api/projects.*', project_services.ProjectService), ('/_api/teams.*', team_services.TeamService), ('/_api/users.*', user_services.UserService), ), registry_path='/_api/protorpc') def domain_middleware(conditions_and_apps): def middleware(environ, start_response): for condition_func, app in conditions_and_apps: if condition_func(environ['SERVER_NAME'], path=environ['PATH_INFO']): return app(environ, start_response) return middleware def allowed_user_domains_middleware(app):
@remote.method(OrganizationPayload, OrganizationPayload) def get(self, message): """Get organization.""" props = dict() return OrganizationPayload(**props) @remote.method(PagePayload, PagePayload) def page(self, message): """Return page of organizations.""" curs = None if message.cursor: curs = Cursor(urlsafe=message.cursor) page, next, more = Organization.page(message.limit, cursor=curs, format='message') return page class OrganizationAsync(webapp2.RequestHandler): """Async organization handler for taskqueue def.""" def post(self): """Dispatches incoming task job.""" pass # RPC service endpoint. rpc = service.service_mappings([('/service/organization', OrganizationRPC),],) # Taskqueue endpoint for async services. handler = webapp2.WSGIApplication([ ('/api/async/organization', OrganizationAsync),], debug=True)
return GetMovieListResponse(result=movie_titles) # Deletes a movie my omdb id @remote.method(DeleteMovieRequest, DeleteMovieResponse) def delete_movie(self, request): q = db_movie.Movie.query() movie = q.filter(db_movie.Movie.omdb_id == request.omdb_id).get() if movie: movie.key.delete() return DeleteMovieResponse( result=DELETE_MOVIE_SUCCESS_MSG % request.omdb_id if movie else DELETE_MOVIE_FAILURE_MSG % request.omdb_id) # Adds a movie by title @remote.method(AddMovieRequest, AddMovieResponse) def add_movie(self, request): moviefetcher = MovieFetcher() success = moviefetcher.get_movie_by_title(request.api_key, request.title) return AddMovieResponse( result=ADD_MOVIE_SUCCESS_MSG % request.title if success else ADD_MOVIE_FAILURE_MSG % request.title) # Map the RPC service and path (/api) app = service.service_mappings([('/api.*', ApiService)])
from protorpc.wsgi import service as wsgi_service import businesspageforms_service import feedbackpageforms_service service = wsgi_service.service_mappings([ ('/forms/businesspage', businesspageforms_service.PostService), ('/forms/feedbackpage', feedbackpageforms_service.PostService) ])
from . import handlers from products import services as product_services from protorpc.wsgi import service import webapp2 app = webapp2.WSGIApplication(( ('/', handlers.MainHandler), )) api_app = service.service_mappings(( ('/_api/products.*', product_services.ProductService), ))
__author__ = 'aparbane' from web.joinhour.services.companion_ship_rating_service import CompanionShipRatingService from protorpc.wsgi import service app = service.service_mappings([('/companion_ship_rating_service', CompanionShipRatingService)])
('/_grow/access-requests/approve/(.*)', access_requests.ApproveAccessRequestHandler), ('/_grow/access-requests/process', access_requests.ProcessHandler), ('/_grow/access-requests', access_requests.ManageAccessHandler), ('/_grow/users/csv', access_requests.DownloadCsvHandler), ('/_grow/users/import', access_requests.ImportFromSheetsHandler), ('/_grow/users/(.*)', access_requests.ManageUserHandler), ('/_grow/users', access_requests.ManageUsersHandler), ('/_grow/protected/cache-sheets', protected_middleware.CacheSheetsHandler), ('/_grow/search/index', search_app.IndexHandler), ('/_ah/warmup', search_app.IndexHandler), ], config=build_server_config) root = build_server_config['root'] locales = build_server_config['locales'] default_locale = build_server_config['default_locale'] static_paths = build_server_config['static_paths'] _static_app = StaticFileServerApplication(root=root) _locale_app = LocaleRedirectMiddleware( _static_app, root=root, locales=locales, default_locale=default_locale) _protected_app = protected_middleware.ProtectedMiddleware(_locale_app, config=build_server_config) app = SheetsAuthMiddleware( _protected_app, static_paths=static_paths, config=build_server_config) api = cors.CorsMiddleware(service.service_mappings([ ('/_grow/api/users.*', users.UsersService), ('/_grow/api/search.*', search_app.SearchService), ]))
Returns: An updated ChecklistITemMessageUpdate message. """ item = ndb.Key(urlsafe=request.checklist_item.key).get() if item: item.FromRpcMessage(request.checklist_item) item.put() request.checklist_item = item.ToRpcMessage() return request @remote.method(message_types.VoidMessage, protorpc_messages.ChecklistItems) def GetAllItems(self, request): """Gets all items from the datastore with a limit of 1000 items. Args: request; VoidMessage: A VoidMessage instance. Returns: A populated ChecklistItems ProtoRPC response message. """ response = protorpc_messages.ChecklistItems() query = models.ChecklistItem().query() response.checklist_items = [ item.ToRpcMessage() for item in query.fetch(limit=1000) ] return response app = service.service_mappings([('/ChecklistService', ChecklistService)])
# Create the RPC service to exchange messages class CoachService(remote.Service): @remote.method(CoachRequest, Coaches) def coach(self, request): cacheKey = 'AllCoaches' if (request.school is not None) and (request.season is None): cacheKey = request.school else: cacheKey = request.season + request.school theCache = memcache.get(cacheKey) if theCache is None: t = Team() coaches = [] for team in t.getCoaches(request.school, request.season): coach = Coach(team_id=team.teamId, name=team.coach, school=team.school, grade=team.grade) coaches.append(coach) if not memcache.add(cacheKey, coaches): logging.error('Unable to set cache') return Coaches(coaches=coaches) else: return Coaches(coaches=theCache) # Map the RPC service and path (/schedule) app = service.service_mappings([('/coach.*', CoachService)])
type = 'query' query_count = count else: type = 'query-view' query_count = limit params = dict(query=keywords, type=type, count=query_count, latlon=self.cityLatLong, res_counts=json.dumps(res_counts)) taskqueue.add(url='/apitracker', params=params, queue_name="apitracker") else: error = result[0].__class__.__name__ params = dict(error=error, query=keywords, type='query', latlon=self.cityLatLong) taskqueue.add(url='/apitracker', params=params, queue_name="apitracker") response = RecordList(error=unicode(error)) return response if cursor: cursor = cursor.web_safe_string items = [RecordPayload(id=x['keyname'], json=json.dumps(x)) \ for x in recs if x] response = RecordList(items=items, cursor=cursor, count=count) return response @remote.method(RecordList, RecordList) def count(self, message): q = json.loads(message.q) return RecordList(count=RecordIndex.search(q, None, count=True)) rpc = service.service_mappings([('/service/rpc/record', RecordService),],)
away = messages.StringField(4, required=True) location = messages.StringField(5, required=True) game_id = messages.StringField(6, required=True) score = messages.StringField(7) class GamesMultiTeamRequest(messages.Message): team_ids = messages.StringField(1, required=True) # Create the response string class GamesMultiTeamResponse(messages.Message): games = messages.MessageField(Games, 1, repeated=True) # Create the RPC service to exchange messages class GamesMultiTeamService(remote.Service): @remote.method(GamesMultiTeamRequest, GamesMultiTeamResponse) def games(self, request): t = Team() responseArray = [] schedule = t.getGamesMultiTeams(request.team_ids) gamesArray = eval(schedule) for game in gamesArray: logging.info(game) responseGame = Games(game_date=game['game_date'][5:], time=game['time'], home=game['home'], away=game['away'], location=game['location'], game_id=game['id'], score=game['score']) responseArray.append(responseGame) return GamesMultiTeamResponse(games=responseArray) # Map the RPC service and path (/schedule) app = service.service_mappings([('/multigames.*', GamesMultiTeamService)])
from protorpc import messages from protorpc import remote from protorpc.wsgi import service from team import Team import logging package = 'SaintsSchedule' class ScheduleRequest(messages.Message): team_id = messages.StringField(1, required=True) # Create the response string class ScheduleResponse(messages.Message): schedule = messages.StringField(1, required=True) # Create the RPC service to exchange messages class ScheduleService(remote.Service): @remote.method(ScheduleRequest, ScheduleResponse) def schedule(self, request): t = Team() games = t.getGames(request.team_id) logging.info("games = " + games) return ScheduleResponse(schedule=games) # Map the RPC service and path (/schedule) app = service.service_mappings([('/schedule.*', ScheduleService)])
logging.info('Ping Response - {}'.format(str(response))) return TBANSResponse(code=response.status_code, message=response.content) else: return self._application_error( 'Did not specify FCM or webhook to ping') @remote.method(VerificationRequest, VerificationResponse) def verification(self, request): """ Immediately dispatch a Verification to a webhook """ self._validate_authentication() from tbans.models.notifications.verification import VerificationNotification notification = VerificationNotification(request.webhook.url, request.webhook.secret) from tbans.models.requests.notifications.webhook_request import WebhookRequest webhook_request = WebhookRequest(notification, request.webhook.url, request.webhook.secret) logging.info('Verification - {}'.format(str(webhook_request))) response = webhook_request.send() logging.info('Verification Response - {}'.format(str(response))) return VerificationResponse( code=response.status_code, message=response.content, verification_key=notification.verification_key) app = service.service_mappings([('/tbans.*', TBANSService)])
import appengine_config from . import services from protorpc.wsgi import service api_app = service.service_mappings(( ('/_api/campaigns.*', services.CampaignService), ('/_api/orders.*', services.OrderService), ))