def registry_command(options, host, service_name=None, registry_path='/protorpc'): """Generate source directory structure from remote registry service. Args: options: Parsed command line options. host: Web service host where registry service is located. May include port. service_name: Name of specific service to read. Will generate only Python files that service is dependent on. If None, will generate source code for all services known by the registry. registry_path: Path to find registry if not the default 'protorpc'. """ dest_dir = os.path.expanduser(options.dest_dir) url = 'http://%s%s' % (host, registry_path) reg = registry.RegistryService.Stub(transport.HttpTransport(url)) if service_name is None: service_names = [service.name for service in reg.services().services] else: service_names = [service_name] file_set = reg.get_file_set(names=service_names).file_set for file_descriptor in file_set.files: generate_file_descriptor(dest_dir, file_descriptor=file_descriptor, force_overwrite=options.force)
def GetServiceStub(self, service, url=None): """Retrieve a service stub to use to test the service calls.""" if not url: url = '/_ah/spi/{}'.format(service.__name__) service_transport = transport.HttpTransport(self._MakeServiceUrl(url), protocol=protojson) return service.Stub(service_transport)
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 testHttpSocketError(self): self.ResetServer( wsgi_util.static_page(self.encoded_response, content_type='application/json')) bad_transport = transport.HttpTransport('http://localhost:-1/blar') try: bad_transport.send_rpc(my_method.remote, self.request) except remote.NetworkError as err: self.assertTrue(str(err).startswith('Socket error: error (')) self.assertEquals(errno.ECONNREFUSED, err.cause.errno) else: self.fail('Expected error')
def testAlternateProtocols(self): self.protocols = remote.Protocols() self.protocols.add_protocol(protojson, 'altproto', 'image/png') global_protocols = remote.Protocols() global_protocols.add_protocol(protojson, 'server-side-name', 'image/png') remote.Protocols.set_default(global_protocols) self.ResetServer() self.connection = transport.HttpTransport( self.service_url, protocol=self.protocols.lookup_by_name('altproto')) self.stub = webapp_test_util.TestService.Stub(self.connection) self.stub.optional_message(string_value='alternate-protocol')
def testURLError(self): trans = transport.HttpTransport('http://myserver/myservice', protocol=protojson) urllib2.urlopen(mox.IsA(urllib2.Request)).AndRaise( urllib2.URLError('a bad connection')) self.mox.ReplayAll() request = Message(value=u'The request value') rpc = trans.send_rpc(my_method.remote, request) rpc.wait() self.assertEquals(remote.RpcState.NETWORK_ERROR, rpc.state) self.assertEquals('Network Error: a bad connection', rpc.error_message) self.assertEquals(None, rpc.error_name)
def setUp(self): super(HttpTransportUrllibTest, self).setUp() self.original_urlfetch = transport.urlfetch transport.urlfetch = None self.trans = transport.HttpTransport('http://myserver/myservice', protocol=protojson) self.request = Message(value=u'The request value') self.encoded_request = protojson.encode_message(self.request) self.response = Message(value=u'The response value') self.encoded_response = protojson.encode_message(self.response) self.mox = mox.Mox() self.mox.StubOutWithMock(urllib2, 'urlopen')
def setUp(self): super(HttpTransportUrlfetchTest, self).setUp() self.trans = transport.HttpTransport('http://myserver/myservice', protocol=protojson) self.request = Message(value=u'The request value') self.encoded_request = protojson.encode_message(self.request) self.response = Message(value=u'The response value') self.encoded_response = protojson.encode_message(self.response) self.mox = mox.Mox() self.mox.StubOutWithMock(urlfetch, 'create_rpc') self.mox.StubOutWithMock(urlfetch, 'make_fetch_call') self.urlfetch_rpc = self.mox.CreateMockAnything()
def testAlwaysUseDefaults(self): new_protocols = remote.Protocols() new_protocols.add_protocol(protojson, 'altproto', 'image/png') self.connection = transport.HttpTransport( self.service_url, protocol=new_protocols.lookup_by_name('altproto')) self.stub = webapp_test_util.TestService.Stub(self.connection) self.assertRaisesWithRegexpMatch( remote.ServerError, 'HTTP Error 415: Unsupported Media Type', self.stub.optional_message, string_value='alternate-protocol') remote.Protocols.set_default(new_protocols) self.stub.optional_message(string_value='alternate-protocol')
def main(argv): options = parse_options(argv[1:]) registry_url = 'http://%s%s' % (options.server, options.registry_path) http_transport = transport.HttpTransport(registry_url, protocol=protojson) remote_registry = registry.RegistryService.Stub(http_transport) # Get complete list of services. services = remote_registry.services() # Get file set for all services on server. get_file_set = registry.GetFileSetRequest() get_file_set.names = [service.name for service in services.services] file_set = remote_registry.get_file_set(get_file_set).file_set # Save file sets to disk. output = open(options.output, 'wb') try: output.write(protobuf.encode_message(file_set)) finally: output.close()
from google.appengine.ext.webapp import template from google.appengine.ext.webapp import util from protorpc import transport import tunes_db if os.environ['SERVER_SOFTWARE'].startswith('Development'): TUNES_DB_HOST = 'localhost:8082' else: TUNES_DB_HOST = 'tunes-db.appspot.com' TUNES_DB_URL = 'http://%s/music' % TUNES_DB_HOST PAGE_SIZE = 10 music_service = tunes_db.MusicLibraryService.Stub( transport.HttpTransport(TUNES_DB_URL)) class MainHandler(webapp.RequestHandler): """Base handler for all handlers of the Tunes DB client. By default any call to get redirects to the Artists page. """ def go(self, page, **kwargs): """Redirection that preserves basic search parameters. Args: page: Page to redirect to. kwargs: Additional parameters to add to query parameter of redirection. """ kwargs.update({
def _CreateTransport(self, protocol=protojson): """Create a new transportation object.""" return transport.HttpTransport(self._MakeServiceUrl( self._ENDPOINTS_SERVICE_PATH), protocol=protocol)
def CreateTransport(self, service_url): """Create a new transportation object.""" return transport.HttpTransport(service_url, protocol=protojson)
def _create_service(): url = 'https://{}/tbans/tbans'.format(app_identity.get_default_version_hostname()) return TBANSService.Stub(transport.HttpTransport(url))
# import appengine_config import os from google.appengine.ext import webapp from google.appengine.ext.webapp import util from protorpc import transport from protorpc import protojson import guestbook postservice = guestbook.PostService.Stub( transport.HttpTransport('http://postservice-demo.appspot.com/postservice')) class MainHandler(webapp.RequestHandler): def get(self): notes = postservice.get_notes(limit=10) self.response.out.write('Last %d posts...' % len(notes.notes)) for note in notes.notes: self.response.out.write('<p>%s' % note.text) def main(): application = webapp.WSGIApplication([('/', MainHandler)], debug=True) util.run_wsgi_app(application)