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)