def test_close_session(self): client = ServerProxy('http://localhost/test_xmlrpc_ok', loop=self.loop) response = self.loop.run_until_complete( client.name.space.proxfyiedcall()) self.assertEqual(response, 1) self.assertIs(self.loop, client._loop) self.loop.run_until_complete(client.close())
def test_close_session(self): client = ServerProxy('http://localhost/test_xmlrpc_ok', loop=self.loop) response = self.loop.run_until_complete( client.name.space.proxfyiedcall() ) self.assertEqual(response, 1) self.assertIs(self.loop, client._loop) self.loop.run_until_complete(client.close())
def test_close_transport(self): from aioxmlrpc.client import ServerProxy, AioTransport transp = AioTransport(use_https=False, loop=self.loop) transp._connector.close = mock.Mock() client = ServerProxy('http://localhost/test_xmlrpc_ok', loop=self.loop, transport=transp) response = self.loop.run_until_complete( client.name.space.proxfyiedcall()) client.close() self.assertEqual(response, 1) self.assertIs(self.loop, client._loop) self.assertTrue(transp._connector.close.called)
def test_http_500(self): client = ServerProxy('http://localhost/test_http_500', loop=self.loop, session=self.session) with self.assertRaises(ProtocolError): self.loop.run_until_complete(client.name.space.proxfyiedcall())
def test_xmlrpc_fault(self): client = ServerProxy('http://localhost/test_xmlrpc_fault', loop=self.loop, session=self.session) with self.assertRaises(Fault): self.loop.run_until_complete(client.name.space.proxfyiedcall())
def test_xmlrpc_ok(self): from aioxmlrpc.client import ServerProxy client = ServerProxy('http://localhost/test_xmlrpc_ok', loop=self.loop) response = self.loop.run_until_complete( client.name.space.proxfyiedcall()) self.assertEqual(response, 1) self.assertIs(self.loop, client._loop)
async def remote_estimate(n): print(f"Requesting that slave estimate pi with {n} throws.") # Create the proxy in a nice way so it gets closed when we are done. async with ServerProxy('http://localhost:9000') as proxy: pi_remote = await proxy.estimate_pi(n) print(f"Result of remote estimation: pi={pi_remote:.010f}") return pi_remote
def from_opensubtitles(media_path, requested_language=None): searches = [] hash, size = hash_opensubtitles(media_path) if hash is not None: server = ServerProxy('http://api.opensubtitles.org/xml-rpc') log.debug("Authenticating to opensubtitles") response = yield from server.LogIn('', '', 'eng', 'aesop v0.1') token = response['token'] searches.append({'moviehash': hash, 'moviebytesize': str(size)}) log.debug("Searching opensubtitles for {}", searches) response = yield from server.SearchSubtitles(token, searches) raw_subtitles = response['data'] if not raw_subtitles: raw_subtitles = [] subtitles = [] for subtitle in raw_subtitles: lang = subtitle['SubLanguageID'] url = subtitle['SubDownloadLink'] downloads = subtitle['SubDownloadsCnt'] format = subtitle['SubFormat'] if format != 'srt': continue if requested_language is not None and lang != requested_language: continue sub = AvailableSubtitle(downloads, lang, url) subtitles.append(sub) yield from server.LogOut(token) yield from server.close() else: subtitles = [] log.info("{} subtitles for {}", len(subtitles), media_path) return subtitles
def test_xmlrpc_ok_global_loop(self): loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) from aioxmlrpc.client import ServerProxy client = ServerProxy('http://localhost/test_xmlrpc_ok') response = self.loop.run_until_complete( client.name.space.proxfyiedcall()) self.assertIs(loop, client._loop) self.assertEqual(response, 1)
def routine(future, endpoint, apikey): api = ServerProxy(endpoint, allow_none=True) result = yield from api.version.info(apikey) future.set_result(result)
def test_http_500(self): from aioxmlrpc.client import ServerProxy, ProtocolError client = ServerProxy('http://localhost/test_http_500', loop=self.loop) self.assertRaises(ProtocolError, self.loop.run_until_complete, client.name.space.proxfyiedcall())
def test_xmlrpc_fault(self): from aioxmlrpc.client import ServerProxy, Fault client = ServerProxy('http://localhost/test_xmlrpc_fault', loop=self.loop) self.assertRaises(Fault, self.loop.run_until_complete, client.name.space.proxfyiedcall())
def main(): client = ServerProxy(ENDPOINT, allow_none=True) for _ in range(5): data = yield from client.version.info() print(data) yield from client.close()
def test_http_error(self): client = ServerProxy('http://nonexistent/nonexistent', loop=self.loop, session=self.session) with self.assertRaises(ProtocolError): self.loop.run_until_complete(client.name.space.proxfyiedcall())
def run_server(hostname, port, htpasswd, token_secret, postgres_uri, trac_xmlrpc_uri, *, svn_uri, svn_username=None, svn_password=None, worker_ssh_params, enable_cors=False, skip_svn_sync=False, skip_trac_sync=False, skip_checking=False, skip_reporting=False): shutdown_timeout = 10 credentials_checker = HtpasswdCredentialsChecker(htpasswd) token_provider = JWTTokenProvider(token_secret) loop = asyncio.get_event_loop() if False: # TODO: asyncssh currently broken due to this asyncio.set_event_loop(None) # See <https://github.com/python/asyncio/issues/478#issuecomment-268476438> # for details. asyncio.get_child_watcher().attach_loop(loop) _setup_termination(loop=loop) _setup_sentry(loop=loop) with contextlib.ExitStack() as exit_stack: exit_stack.callback(loop.close) db = Database(postgres_uri, loop=loop) loop.run_until_complete(db.start()) exit_stack.callback( lambda: loop.run_until_complete(db.stop())) trac_rpc = ServerProxy(trac_xmlrpc_uri, loop=loop) exit_stack.callback(trac_rpc.close) async def do_tickets_sync(): await sync_tickets( db, trac_rpc, COMPONENT_TO_ASSIGNMENT_ID) async def do_svn_sync(): await sync_svn( db, PATH_TO_ASSIGNMENT_ID, svn_uri=svn_uri, svn_username=svn_username, svn_password=svn_password, loop=loop) async def do_check_solutions(): await check_solutions(db, LINKED_PTR_ASSIGNMENT_ID, ssh_params=worker_ssh_params, loop=loop) await check_solutions(db, LAZY_STRING_ASSIGNMENT_ID, ssh_params=worker_ssh_params, loop=loop) await check_solutions(db, FUNCTION_ASSIGNMENT_ID, ssh_params=worker_ssh_params, loop=loop) await check_solutions(db, BIND_ASSIGNMENT_ID, ssh_params=worker_ssh_params, loop=loop) async def do_post_reports(): await report_solutions( db, trac_rpc, LINKED_PTR_ASSIGNMENT_ID, loop=loop) await report_solutions( db, trac_rpc, LAZY_STRING_ASSIGNMENT_ID, loop=loop) await report_solutions( db, trac_rpc, FUNCTION_ASSIGNMENT_ID, loop=loop) await report_solutions( db, trac_rpc, BIND_ASSIGNMENT_ID, loop=loop) # if False: # loop.run_until_complete( # db.get_checkable_solutions(ASSIGNMENT_ID)) # return # if False: # loop.run_until_complete( # check_solutions(db, ASSIGNMENT_ID, # ssh_params=worker_ssh_params, loop=loop)) # return # if False: # loop.run_until_complete( # report_solutions(db, trac_rpc, ASSIGNMENT_ID, # loop=loop)) # return if _DEBUG_SYNC_TICKETS: loop.run_until_complete(do_tickets_sync()) if _DEBUG_SYNC_SVN: loop.run_until_complete(do_svn_sync()) if not skip_svn_sync: svn_sync = PeriodicScheduler( do_svn_sync, 30, "svn_sync", timeout=60 * 10, loop=loop) loop.run_until_complete(svn_sync.start()) exit_stack.callback(lambda: loop.run_until_complete(svn_sync.stop())) if not skip_trac_sync: trac_sync = PeriodicScheduler( do_tickets_sync, 600, "trac_sync", timeout=60 * 10, loop=loop) loop.run_until_complete(trac_sync.start()) exit_stack.callback(lambda: loop.run_until_complete(trac_sync.stop())) if not skip_checking: check_solutions_sync = PeriodicScheduler( do_check_solutions, 30, "check_solutions_sync", timeout=60 * 10, loop=loop) loop.run_until_complete(check_solutions_sync.start()) exit_stack.callback(lambda: loop.run_until_complete(check_solutions_sync.stop())) if not skip_reporting: post_reports = PeriodicScheduler( do_post_reports, 30, "post_reports", timeout=60 * 10, loop=loop) loop.run_until_complete(post_reports.start()) exit_stack.callback(lambda: loop.run_until_complete(post_reports.stop())) app = aiohttp.web.Application(loop=loop) # Start application server. app_server = Server( app, credentials_checker, token_provider, db, loop=loop, enable_cors=enable_cors) loop.run_until_complete(app_server.start()) handler = app.make_handler() socket_server = loop.run_until_complete( loop.create_server(handler, hostname, port)) def stop_app(): _logger.info("Stopping web application...") socket_server.close() loop.run_until_complete(socket_server.wait_closed()) loop.run_until_complete(app.shutdown()) loop.run_until_complete( handler.finish_connections(shutdown_timeout)) loop.run_until_complete(app.cleanup()) # Stop our server first to allow graceful termination of persistent # connections (e.g. WebSockets). # Notice that top of the stack will be executed earlier. exit_stack.callback(stop_app) exit_stack.callback( lambda: loop.run_until_complete(app_server.stop())) url = yarl.URL('http://example.org').\ with_host(hostname).with_port(port) _logger.info("Server started on {}".format(url.human_repr())) loop.run_forever() return 0
def main(): client = ServerProxy(ENDPOINT, allow_none=True) for _ in range(5): data = yield from client.version.info() print(data) yield from client.close()
class Requester: def __init__(self, credentials: CredentialsBase): self.cred = credentials self.common = AioServerProxy( f'https://{self.cred.domain}/xmlrpc/2/common') self.models = AioServerProxy( f'https://{self.cred.domain}/xmlrpc/2/object') async def execute_kw(self, *args, **kwargs): try: return await self.models.execute_kw(self.cred.db, self.cred.uid, self.cred.dbpass, *args, kwargs) except xmlrpc.client.Fault as exc: if exc.faultCode == 3: print('Credentials ot working. trying re-login') else: raise await self.login(force=True) return self.models.execute_kw(self.cred.db, self.cred.uid, self.cred.dbpass, *args, kwargs) async def login(self, force=False): if self.cred.uid is not None and not force: return uid = await self.common.authenticate(self.cred.db, self.cred.mno, self.cred.dbpass, {}) if uid is not False: self.cred.uid = uid return try: self.cred.get_or_set( 'dbpass', 'login failed for {user}@{db}. Reenter password', passw=True, force=True) except KeyboardInterrupt: try: i = int( input(""" options: [1] change user [2] change db [3] exit choice: """)) except ValueError as exc: raise ValueError('Only integers allowed...') from exc if i == 1: self.cred.get_or_set('mno', 'Enter new MemberNumber for {db}: ', force=True) elif i == 3: sys.exit() else: raise NotImplementedError() self.cred.clear('dbpass') await self.login() async def __aenter__(self): await self.login() return self def __exit__(self, exc_type, exc_val, exc_tb): self.close() async def __aexit__(self, *args): return self.__exit__(*args) def close(self): self.common.close() self.models.close()
def __init__(self, credentials: CredentialsBase): self.cred = credentials self.common = AioServerProxy( f'https://{self.cred.domain}/xmlrpc/2/common') self.models = AioServerProxy( f'https://{self.cred.domain}/xmlrpc/2/object')