def create_proxy(url): parsed = urlsplit(url) proto = url.split(':')[0].lower() if proto == 'scgi': if parsed.netloc: url = 'http://%s' % parsed.netloc logger.debug('Creating SCGI XMLRPC Proxy with url %r' % url) return ServerProxy(url, transport=SCGITransport()) else: path = parsed.path logger.debug('Creating SCGI XMLRPC Socket Proxy with socket file %r' % path) return ServerProxy('http://1', transport=SCGITransport(socket_path=path)) else: logger.debug('Creating Normal XMLRPC Proxy with url %r' % url) return ServerProxy(url)
def test_cobbler_alive(self): """Test current installation has correctly setup cobbler Test disabled and move to fuel_tests suite: fuel_tests.test.test_admin_node.TestAdminNode API and cobbler HTTP server are alive Scenario: 1. Revert snapshot "empty" 2. test cobbler API and HTTP server through send http request Duration 1m """ # pylint: disable=W0101 warn("Test disabled and move to fuel_tests suite", DeprecationWarning) raise SkipTest("Test disabled and move to fuel_tests suite") self.env.revert_snapshot("empty") wait(lambda: http(host=self.env.get_admin_node_ip(), url='/cobbler_api', waited_code=501), timeout=60, timeout_msg='Cobler WEB API is not alive') server = ServerProxy('http://%s/cobbler_api' % self.env.get_admin_node_ip()) config = self.env.admin_actions.get_fuel_settings() username = config['cobbler']['user'] password = config['cobbler']['password'] # raises an error if something isn't right server.login(username, password)
def test_cobbler_alive(self): """Test current installation has correctly setup cobbler API and cobbler HTTP server are alive Scenario: 1. Revert snapshot "empty" 2. test cobbler API and HTTP server through send http request Duration 1m """ wait(lambda: http(host=self.env.get_admin_node_ip(), url='/cobbler_api', waited_code=501), timeout=60) server = ServerProxy('http://%s/cobbler_api' % self.env.get_admin_node_ip()) config = self.env.admin_actions.get_fuel_settings() username = config['cobbler']['user'] password = config['cobbler']['password'] # raises an error if something isn't right server.login(username, password)
def NZBConnection(url): """Method to connect to NZBget client :param url: nzb url to connect :return: True if connected, else False """ nzbGetRPC = ServerProxy(url) try: if nzbGetRPC.writelog('INFO', 'Medusa connected to test connection.'): log.debug('Successfully connected to NZBget') else: log.warning('Successfully connected to NZBget but unable to' ' send a message') return True except socket.error: log.warning('Please check your NZBget host and port (if it is' ' running). NZBget is not responding to this combination') return False except ProtocolError as e: if e.errmsg == 'Unauthorized': log.warning('NZBget username or password is incorrect.') else: log.error('Protocol Error: {msg}', {'msg': e.errmsg}) return False
def test_xmlrpc_server(self, uri='http://127.0.0.1:3423'): from six.moves.xmlrpc_client import ServerProxy client = ServerProxy(uri) assert client.test_1() == 'test_1' assert client.test_3({'asdf':4}) == {'asdf':4}
def ping (self): """ See if Display server present Returns True if server present * self = Display object """ from six.moves.xmlrpc_client import ServerProxy url = self.serverURL if url == "ObitView": url = "http://localhost:8765/RPC2" server = ServerProxy(url) try: answer = server.ping(42) except: answer = False pass else: pass if answer: print("Display Server "+url+" present") return True else: print("Display Server "+url+" NOT present") return False
def setUp(self): from .server import server, start_server self.server = server Thread(target=start_server).start() self.client = ServerProxy('http://localhost:8000/RPC2', transport=LocustXmlRpcTransport()) global_stats.reset_all()
def NZBConnection(url): """Method to connect to NZBget client :param url: nzb url to connect :return: True if connected, else False """ nzbGetRPC = ServerProxy(url) try: if nzbGetRPC.writelog('INFO', 'Medusa connected to test connection.'): logger.log('Successful connected to NZBget', logger.DEBUG) else: logger.log('Successful connected to NZBget, but unable to send a message', logger.WARNING) return True except socket.error: logger.log( 'Please check your NZBget host and port (if it is running). NZBget is not responding to this combination', logger.WARNING) return False except ProtocolError as e: if e.errmsg == 'Unauthorized': logger.log('NZBget username or password is incorrect.', logger.WARNING) else: logger.log('Protocol Error: ' + e.errmsg, logger.ERROR) return False
def proxy(self): """Return the proxy through which this FITS disk can be accessed.""" if self.url: return ServerProxy(self.url) else: return LocalProxy
def test_server(host='localhost', port=4966): """Test for a Larch server on host and port Arguments host (str): host name ['localhost'] port (int): port number [4966] Returns integer status number: 0 Not in use. 1 Connected, valid Larch server 2 In use, but not a valid Larch server """ server = ServerProxy('http://%s:%d' % (host, port)) try: methods = server.system.listMethods() except socket.error: return NOT_IN_USE # verify that this is a valid larch server if len(methods) < 5 or 'larch' not in methods: return NOT_LARCHSERVER ret = '' try: ret = server.get_rawdata('_sys.config.user_larchdir') except: return NOT_LARCHSERVER if len(ret) < 1: return NOT_LARCHSERVER return CONNECTED
def __init__(self, username=None, password=None): self.server = ServerProxy(self.server_url, TimeoutSafeTransport(10)) if any((username, password)) and not all((username, password)): raise ConfigurationError('Username and password must be specified') # None values not allowed for logging in, so replace it by '' self.username = username or '' self.password = password or '' self.token = None
def _errata_service(self): # XML-RPC client connected to errata_service. # Each thread uses a separate client. if not hasattr(self._tls, "errata_service"): url = self._errata_service_url LOG.debug("Creating XML-RPC client for Errata Tool: %s", url) self._tls.errata_service = ServerProxy(url) return self._tls.errata_service
def __init__(self, username=None, password=None): self.server = ServerProxy('https://api.opensubtitles.org/xml-rpc', TimeoutSafeTransport(10)) if username and not password or not username and password: raise ConfigurationError('Username and password must be specified') # None values not allowed for logging in, so replace it by '' self.username = username or '' self.password = password or '' self.token = None
def __init__(self, configuration=None, name=None): SimpleService.__init__(self, configuration=configuration, name=name) self.order = ORDER self.definitions = CHARTS self.host = self.configuration.get(CONF_PARAM_HOST, DEFAULT_HOST) try: self.server = ServerProxy(self.host, allow_none=True) except: self.server = None
def download_data(file, group, station_id, start, end, get_blobs=False): """Download raw data from the datastore This function downloads data from the datastore, using the XML-RPC API exposed by the public database. :param file: The PyTables datafile handler :param group: The PyTables destination group, which need not exist :param station_id: The HiSPARC station number for which to get events :param start: a datetime instance defining the start of the search interval :param end: a datetime instance defining the end of the search interval :param get_blobs: boolean, select whether binary data like traces should be fetched Example:: >>> import tables >>> import datetime >>> import sapphire.publicdb >>> data = tables.open_file('data.h5', 'w') >>> start = datetime.datetime(2010, 9, 1) >>> end = datetime.datetime(2010, 9, 2) >>> sapphire.publicdb.download_data(data, '/s501', 501, start, end) INFO:hisparc.publicdb:2010-09-01 00:00:00 None INFO:hisparc.publicdb:Getting server data URL (2010-09-01 00:00:00) INFO:hisparc.publicdb:Downloading data... INFO:hisparc.publicdb:Storing data... INFO:hisparc.publicdb:Done. """ server = ServerProxy(PUBLICDB_XMLRPC_URL) for t0, t1 in datetimerange(start, end): logger.info("%s %s" % (t0, t1)) logger.info("Getting server data URL (%s)" % t0) try: url = server.hisparc.get_data_url(station_id, t0, get_blobs) except Exception as exc: if re.search("No data", str(exc)): logger.warning("No data for %s" % t0) continue else: raise logger.info("Downloading data...") tmp_datafile, headers = urlretrieve(url) logger.info("Storing data...") _store_data(file, group, tmp_datafile, t0, t1) logger.info("Done.")
def _ensure_login(self): """ Ensure that the server is opened :return: :rtype: """ if self.server is None: self.server = ServerProxy('https://api.opensubtitles.org/xml-rpc', TimeoutSafeTransport(100)) self.logger.info('Logging in') response = checked(self.server.LogIn('', '', 'eng', 'subfind v1')) self.token = response['token'] self.logger.debug('Logged in with token %r', self.token)
def available_on_pypi(prerelease=current_version.is_prerelease): """Return True if an update is available on PyPI. >>> available_on_pypi() # doctest: +ELLIPSIS <Version('...')> >>> available_on_pypi(prerelease=False).is_prerelease False """ client = ServerProxy('https://pypi.python.org/pypi') versions = client.package_releases('pwntools', True) versions = map(packaging.version.Version, versions) if not prerelease: versions = filter(lambda v: not v.is_prerelease, versions) return max(versions)
def abort(self): """ Abort task """ #print "in abort" if self.done: return # Abort task self.myTask.abort(self.proxy, self.tid) self.done = True # Update message window server = ServerProxy(self.url) arg = {"taskID":self.taskID, "message":"Task Aborted\n"} answer = server.DisplayMessage(arg) arg = {"taskID":self.taskID, "status":"Task Aborted"} answer = server.SetStatus(arg)
def test_sleep(self): client = ServerProxy('http://localhost:%d/RPC2' % SERVERPORT, allow_none=True) start = time() client.sleep(0.1) end = time() delta = end - start dummy_log(local().current) self.assertGreater(delta, 0.101) traces = DummyClient._client.messages self.assertEqual( len(traces), 1, "There should be one trace for " "the request just processed")
def convert(self, key): in_fn = "data/{}.blob".format(key) in_mime_type = open("data/{}.mime".format(key)).read() file_extension = mimetypes.guess_extension(in_mime_type).strip(".") data = b64encode(open(in_fn, "rb").read()) proxy = ServerProxy(self.SERVER_URL, allow_none=True) if in_mime_type.startswith("application/vnd.oasis.opendocument"): data = proxy.convertFile(data, file_extension, "pdf") else: pivot_format = self.pivot_format_map[file_extension] data = proxy.convertFile(data, file_extension, pivot_format) data = proxy.convertFile(data, pivot_format, "pdf") converted = b64decode(data) new_key = hashlib.md5(converted).hexdigest() with open("data/{}.blob".format(new_key), "wb") as fd: fd.write(converted) return new_key
def __init__(self, context): self._serverproxy_list = [] preference_tool = getToolByName(context, 'portal_preferences') self._ooo_server_retry = ( preference_tool.getPreferredDocumentConversionServerRetry() or DOCUMENT_CONVERSION_SERVER_RETRY) uri_list = preference_tool.getPreferredDocumentConversionServerUrlList( ) if not uri_list: address = preference_tool.getPreferredOoodocServerAddress() port = preference_tool.getPreferredOoodocServerPortNumber() if not (address and port): raise ConversionError( 'OOoDocument: cannot proceed with conversion:' ' conversion server url is not defined in preferences') LOG('Document', WARNING, 'PreferredOoodocServer{Address,PortNumber}' + \ ' are DEPRECATED please use PreferredDocumentServerUrl instead', error=True) uri_list = ['%s://%s:%s' % ('http', address, port)] timeout = (preference_tool.getPreferredOoodocServerTimeout() or DOCUMENT_CONVERSION_SERVER_PROXY_TIMEOUT) for uri in uri_list: if uri.startswith("http://"): scheme = "http" elif uri.startswith("https://"): scheme = "https" else: raise ConversionError( 'OOoDocument: cannot proceed with conversion:' ' preferred conversion server url is invalid') from erp5.component.module.TimeoutTransport import TimeoutTransport transport = TimeoutTransport(timeout=timeout, scheme=scheme) self._serverproxy_list.append( (uri, ServerProxy(uri, allow_none=True, transport=transport)))
def available_on_pypi(prerelease=current_version.is_prerelease): """Return True if an update is available on PyPI. >>> available_on_pypi() # doctest: +ELLIPSIS <Version('...')> >>> available_on_pypi(prerelease=False).is_prerelease False """ # Deferred import to save startup time from six.moves.xmlrpc_client import ServerProxy versions = getattr(available_on_pypi, 'cached', None) if versions is None: client = ServerProxy('https://pypi.python.org/pypi') versions = client.package_releases('pwntools', True) available_on_pypi.cached = versions versions = map(packaging.version.Version, versions) if not prerelease: versions = filter(lambda v: not v.is_prerelease, versions) return max(versions)
#!/usr/bin/env python from six.moves.xmlrpc_client import ServerProxy import time import json from larch.utils.jsonutils import decode4js s = ServerProxy('http://127.0.0.1:4966') print('Avaialable Methods from XML-RPC server: ', s.system.listMethods()) s.larch('m = 222.3') s.larch('g = group(x=linspace(0, 10, 11))') s.larch('g.z = cos(g.x)') # show and print will be done in server process of course!!! s.larch('show(g)') s.larch('print( g.z[3:10])') print('== Messages:') print(s.get_messages()) print('==') gx = decode4js(s.get_data('g.z')) print('m = ', s.get_data('m')) print('x = ', s.get_data('x')) print('gx = ', gx, type(gx), gx.dtype) # could tell server to exit! # s.exit()
def __init__(self, port): ''' Create a new AnalysisRpc Client which will connect on the specified port ''' self._serverProxy = ServerProxy("http://127.0.0.1:%d" % port) self._port = port
def __init__(self, search_url=None): self.server = ServerProxy(self.server_url, TimeoutSafeTransport(10)) # None values not allowed for logging in, so replace it by '' self.token = None self.session = Session() self.search_url = search_url or get_sub_domain()
def run(self): """ Execute and manage task """ ################################################################ TaskWin = self myTask = self.myTask TaskWin.done = False # Start ObitMess Window for task myTask._name try: server = ServerProxy(self.url) answer = server.CreateWindow(myTask._name) self.taskID = answer["taskID"] except Exception as e: print("Failed to talk to ObitMess",e) raise RuntimeError("Cannot talk to ObitMess - start it ") # Hang around until gui is started time.sleep(1.) TaskWin.Started = True deadGUI = False # has GUI died? May want to keep running/logging. arg = {"taskID":self.taskID, "status":"Task Running"} answer = server.SetStatus(arg) deadGUI = deadGUI or (answer['Status']['code']!=0) (TaskWin.proxy, TaskWin.tid) = myTask.spawn() # Logging to file? if len(myTask.logFile)>0: TaskLog = open(myTask.logFile,'a') else: TaskLog = None TaskWin.Failed = False try: while not myTask.finished(TaskWin.proxy, TaskWin.tid): messages = myTask.messages(TaskWin.proxy, TaskWin.tid) if messages: if not deadGUI: msg = "" # Bundle messages for message in messages: if type(message)==str: msg += message+'\n' else: msg += message[1]+'\n' arg = {"taskID":self.taskID, "message":msg} answer = server.DisplayMessage(arg) # loop if busy while answer['Status']['reason']=="Busy": answer = server.DisplayMessage(arg) deadGUI = deadGUI or (answer['Status']['code']!=0) # Abort request? doAbort = answer["Abort"] # Input (AIPS) request in message? if (msg.__contains__("** press RETURN for more") or msg.__contains__("just hit RETURN to continue")): answer = server.UserResponse(self.taskID) # loop if busy while answer['Status']['reason']=="Busy": answer = server.UserResponse(self.taskID) deadGUI = deadGUI or (answer['Status']['code']!=0) doAbort = doAbort or answer["Abort"] reply = answer["Result"] if not TaskWin.done: # Feed the task the command myTask.feed(TaskWin.proxy, TaskWin.tid, reply+"\n") else: # Task finished arg = {"taskID":self.taskID, "message":"Task already finished\n"} answer = server.DisplayMessage(arg) # Now abort if requested if doAbort: time.sleep(1.) # time to shutdown if requested if not myTask.finished(self.proxy, self.tid): # this seems to leave the task in an undead state self.myTask.abort(self.proxy, self.tid) TaskWin.Failed = True TaskWin.done = True # end if GUI alive if TaskLog: for message in messages: if type(message)==str: x=TaskLog.write('%s\n' % message) else: x=TaskLog.write('%s\n' % message[1]) TaskLog.flush() continue except KeyboardInterrupt as exception: print("Something went wrong:",exception) myTask.abort(TaskWin.proxy, TaskWin.tid) raise exception except Exception as e: # Aborts throw exceptions that get caught here TaskWin.Failed = True TaskWin.done = True #print "An exception was thrown, task aborted:",e if not TaskWin.Failed: TaskWin.wait() arg = {"taskID":self.taskID, "status":"Task Finished"} answer = server.SetStatus(arg) else: arg = {"taskID":self.taskID, "status":"Task Failed"} answer = server.SetStatus(arg) TaskWin.done = True if TaskLog: TaskLog.close()
def sendNZB(nzb, proper=False): """ Sends NZB to NZBGet client :param nzb: nzb object :param proper: True if a Proper download, False if not. """ if app.NZBGET_HOST is None: log.warning('No NZBget host found in configuration.' ' Please configure it.') return False addToTop = False nzbgetprio = 0 category = app.NZBGET_CATEGORY if nzb.show.is_anime: category = app.NZBGET_CATEGORY_ANIME url = 'http{}://{}:{}@{}/xmlrpc'.format( 's' if app.NZBGET_USE_HTTPS else '', app.NZBGET_USERNAME, app.NZBGET_PASSWORD, app.NZBGET_HOST) if not NZBConnection(url): return False nzbGetRPC = ServerProxy(url) dupekey = '' dupescore = 0 # if it aired recently make it high priority and generate DupeKey/Score for cur_ep in nzb.episodes: if dupekey == '': if cur_ep.series.indexer == 1: dupekey = 'Medusa-' + str(cur_ep.series.indexerid) elif cur_ep.series.indexer == 2: dupekey = 'Medusa-tvr' + str(cur_ep.series.indexerid) dupekey += '-' + str(cur_ep.season) + '.' + str(cur_ep.episode) if datetime.date.today() - cur_ep.airdate <= datetime.timedelta( days=7): addToTop = True nzbgetprio = app.NZBGET_PRIORITY else: category = app.NZBGET_CATEGORY_BACKLOG if nzb.show.is_anime: category = app.NZBGET_CATEGORY_ANIME_BACKLOG if nzb.quality != Quality.UNKNOWN: dupescore = nzb.quality * 100 if proper: dupescore += 10 nzbcontent64 = None if nzb.result_type == 'nzbdata': data = nzb.extra_info[0] nzbcontent64 = standard_b64encode(data) log.info('Sending NZB to NZBget') log.debug('URL: {}', url) try: # Find out if nzbget supports priority (Version 9.0+), # old versions beginning with a 0.x will use the old command nzbget_version_str = nzbGetRPC.version() nzbget_version = try_int( nzbget_version_str[:nzbget_version_str.find('.')]) if nzbget_version == 0: if nzbcontent64: nzbget_result = nzbGetRPC.append(nzb.name + '.nzb', category, addToTop, nzbcontent64) else: if nzb.result_type == 'nzb': if not nzb.provider.login(): return False # TODO: Check if this needs exception handling data = nzb.provider.session(nzb.url).content if data is None: return False nzbcontent64 = standard_b64encode(data) nzbget_result = nzbGetRPC.append(nzb.name + '.nzb', category, addToTop, nzbcontent64) elif nzbget_version == 12: if nzbcontent64 is not None: nzbget_result = nzbGetRPC.append(nzb.name + '.nzb', category, nzbgetprio, False, nzbcontent64, False, dupekey, dupescore, 'score') else: nzbget_result = nzbGetRPC.appendurl(nzb.name + '.nzb', category, nzbgetprio, False, nzb.url, False, dupekey, dupescore, 'score') # v13+ has a new combined append method that accepts both (url and # content) also the return value has changed from boolean to integer # (Positive number representing NZBID of the queue item. 0 and negative # numbers represent error codes.) elif nzbget_version >= 13: nzbget_result = nzbGetRPC.append( nzb.name + '.nzb', nzbcontent64 if nzbcontent64 is not None else nzb.url, category, nzbgetprio, False, False, dupekey, dupescore, 'score') > 0 else: if nzbcontent64 is not None: nzbget_result = nzbGetRPC.append(nzb.name + '.nzb', category, nzbgetprio, False, nzbcontent64) else: nzbget_result = nzbGetRPC.appendurl(nzb.name + '.nzb', category, nzbgetprio, False, nzb.url) if nzbget_result: log.debug('NZB sent to NZBget successfully') return True else: log.warning('NZBget could not add {name}.nzb to the queue', {'name': nzb.name}) return False except Exception: log.warning( 'Connect Error to NZBget: could not add {file}.nzb to the' ' queue', {'name': nzb.name}) return False
def __init__(self): server_listener_address = 'http://%s:%s' % ( LISTENER_HOST, LISTENER_PORT) self.server = ServerProxy(server_listener_address)
def testXmlRpc(self): scheme = self.scheme if scheme == 'https': url = 'https://%s:%s/xmlrpc/' % (self.interface(), self.PORT) proxy = ServerProxy(url, transport=HTTPSTransport()) else: url = 'http://%s:%s/xmlrpc/' % (self.interface(), self.PORT) proxy = ServerProxy(url) # begin the tests ... self.getPage('/xmlrpc/foo') self.assertBody('Hello world!') self.assertEqual(proxy.return_single_item_list(), [42]) self.assertNotEqual(proxy.return_single_item_list(), 'one bazillion') self.assertEqual(proxy.return_string(), 'here is a string') self.assertEqual(proxy.return_tuple(), list( ('here', 'is', 1, 'tuple'))) self.assertEqual(proxy.return_dict(), {'a': 1, 'c': 3, 'b': 2}) self.assertEqual(proxy.return_composite(), [{ 'a': 1, 'z': 26 }, 'hi', ['welcome', 'friend']]) self.assertEqual(proxy.return_int(), 42) self.assertEqual(proxy.return_float(), 3.14) self.assertEqual(proxy.return_datetime(), DateTime((2003, 10, 7, 8, 1, 0, 1, 280, -1))) self.assertEqual(proxy.return_boolean(), True) self.assertEqual(proxy.test_argument_passing(22), 22 * 2) # Test an error in the page handler (should raise an xmlrpclib.Fault) try: proxy.test_argument_passing({}) except Exception: x = sys.exc_info()[1] self.assertEqual(x.__class__, Fault) self.assertEqual(x.faultString, ('unsupported operand type(s) ' "for *: 'dict' and 'int'")) else: self.fail('Expected xmlrpclib.Fault') # https://github.com/cherrypy/cherrypy/issues/533 # if a method is not found, an xmlrpclib.Fault should be raised try: proxy.non_method() except Exception: x = sys.exc_info()[1] self.assertEqual(x.__class__, Fault) self.assertEqual(x.faultString, 'method "non_method" is not supported') else: self.fail('Expected xmlrpclib.Fault') # Test returning a Fault from the page handler. try: proxy.test_returning_Fault() except Exception: x = sys.exc_info()[1] self.assertEqual(x.__class__, Fault) self.assertEqual(x.faultString, ('custom Fault response')) else: self.fail('Expected xmlrpclib.Fault')
def __init__(self): self.server = ServerProxy('https://api.opensubtitles.org/xml-rpc', TimeoutSafeTransport(10)) self.token = None