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 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 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 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 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 __init__(self, user=None, password=None, server=None, port=None, anon=False): """Initialise an SR trac object.""" config = Config() if server is None: server = config["server"] if port is None: port = config["https_port"] self.server = server self.port = port rpc_settings = {"server": server, "port": port} if anon: rpc_url = "https://{server}:{port}/trac/rpc" else: rpc_url = "https://{user}:{password}@{server}:{port}/trac/login" \ "/rpc" user = config.get_user(user) rpc_settings["user"] = user rpc_settings["password"] = config.get_password(password, user=user) rpc_url = rpc_url.format(**rpc_settings) ServerProxy.__init__(self, rpc_url) if 'ticket.create' not in self.system.listMethods(): raise WrongServer()
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 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 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_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 __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, sock_path): # We can't pass funny characters in the host part of a URL, so we # encode the socket path in base16. ServerProxy.__init__(self, 'http://' + base64.b16encode(sock_path.encode('utf-8')), transport=UnixXmlRpcTransport(), allow_none=1)
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 __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
class RobotListener: ROBOT_LISTENER_API_VERSION = 2 def __init__(self): server_listener_address = 'http://%s:%s' % ( LISTENER_HOST, LISTENER_PORT) self.server = ServerProxy(server_listener_address) def start_test(self, name, attrs): self.server.zodb_setup() def end_test(self, name, attrs): self.server.zodb_teardown()
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 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 proxy(self): """Return the proxy through which this FITS disk can be accessed.""" if self.url: return ServerProxy(self.url) else: return LocalProxy
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 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 __getattr__(self, name): allnames = dir(self) if allnames and name not in allnames: raise AttributeError(name) method = ServerProxy.__getattr__(self, name) # `method` has private __name, so pass it as extra arg to wrapper: return XMLRPCMethod(name, method, client=self)
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 _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 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
class TestTransport(unittest.TestCase): 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 test_returns_something(self): res = self.client.add(2, 2) self.assertEqual(res, 4) stats = global_stats.get('/RPC2', 'xmlrpc') self.assertEqual(stats.num_requests, 1) def test_failure(self): self.client.failure('01', 'Test Error') stats = global_stats.get('/RPC2', 'xmlrpc') self.assertEqual(stats.num_failures, 1) def test_failure_not_found(self): self.client.method_doesnt_exist() stats = global_stats.get('/RPC2', 'xmlrpc') self.assertEqual(stats.num_failures, 1) def test_delay(self): delayed_ms = 500 res = self.client.delayed(delayed_ms) stats = global_stats.get('/RPC2', 'xmlrpc') self.assertEqual(res, delayed_ms) self.assertEqual(stats.num_requests, 1) self.assertGreaterEqual(stats.avg_response_time, delayed_ms) def tearDown(self): self.server.shutdown()
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)
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.")
class Service(SimpleService): 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 check(self): if self.server is None: self.error('error connecting to the sioworkers server {0}'.format( self.host)) return True def get_data(self): if self.server is None: return None capacity = 0 load = 0 workers = self.server.get_workers() for worker in workers: concurrency = worker['info']['concurrency'] capacity += concurrency if bool(worker['is_running_cpu_exec']): load += concurrency else: load += len(worker['tasks']) return dict({'capacity': capacity, 'load': load})
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 larch_server_cli(): """command-line program to control larch XMLRPC server""" __version__ = 'version 2.2' usage = """usage: %prog [options] [start|stop|restart|next|status|report] Commands: start start server on specified port stop stop server on specified port restart restart server on specified port next start server on next avaialable port (see also '-n' option) status print a short status message: whether server is running on port report print a multi-line status report """ parser = OptionParser(usage=usage, prog="larch_server", version="larch_server: %s" % __version__) parser.add_option("-p", "--port", dest="port", default='4966', metavar='PORT', help="port number for server [4966]") parser.add_option("-q", "--quiet", dest="quiet", action="store_true", default=False, help="suppress messaages [False]") parser.add_option("-n", "--next", dest="next", action="store_true", default=False, help="show next available port, but do not start [False]") (options, args) = parser.parse_args() port = int(options.port) command = 'status' def smsg(port, txt): if not options.quiet: print('larch_server port=%i: %s' % (port, txt)) if len(args) > 0: command = args[0].lower() if options.next: port = get_next_port(port=port) print("%i" % port) sys.exit(0) server_state = test_server(port=port) if command == 'start': if server_state == CONNECTED: smsg(port, 'already running') elif server_state == NOT_IN_USE: spawn_server(port=port) smsg(port, 'started') else: smsg(port, 'port is in use, cannot start') elif command == 'stop': if server_state == CONNECTED: ServerProxy('http://localhost:%d' % (port)).shutdown() smsg(port, 'stopped') elif command == 'next': port = get_next_port(port=port) spawn_server(port=port) smsg(port, 'started') elif command == 'restart': if server_state == CONNECTED: ServerProxy('http://localhost:%d' % (port)).shutdown() sleep(POLL_TIME) spawn_server(port=port) elif command == 'status': if server_state == CONNECTED: smsg(port, 'running') sys.exit(0) elif server_state == NOT_IN_USE: smsg(port, 'not running') sys.exit(1) else: smsg(port, 'port is in use by non-larch server') elif command == 'report': if server_state == CONNECTED: s = ServerProxy('http://localhost:%d' % (port)) info = s.get_client_info() last_event = info.get('last_event', 0) last_used = ctime(last_event) serverid = int(info.get('pid_server', 0)) serverport= int(info.get('port', 0)) procid = int(info.get('pid', 0)) appname = info.get('app', 'unknown') machname = info.get('machine', 'unknown') username = info.get('user', 'unknown') keepalive_time = info.get('keepalive_time', -1) keepalive_time += (last_event - time()) keepalive_units = 'seconds' if keepalive_time > 300: keepalive_time = keepalive_time/60.0 keepalive_units = 'minutes' if keepalive_time > 300: keepalive_time = keepalive_time/60.0 keepalive_units = 'hours' print('larch_server report:') print(' Client Machine Name = %s' % machname) print(' Client Process ID = %s' % str(procid)) print(' Client Application = %s' % appname) print(' Client User Name = %s' % username) print(' Client Last Used = %s' % last_used) print(' Server Process ID = %s' % serverid) print(' Server Port Number = %s' % serverport) print(' Server will expire in %i %s if not used.' % (keepalive_time, keepalive_units)) elif server_state == NOT_IN_USE: smsg(port, 'not running') sys.exit(1) else: smsg(port, 'port is in use by non-larch server') else: print("larch_server: unknown command '%s'. Try -h" % command)
def __init__(self): server_listener_address = 'http://%s:%s' % ( LISTENER_HOST, LISTENER_PORT) self.server = ServerProxy(server_listener_address)
class OpenSubtitlesProvider(Provider): """OpenSubtitles Provider. :param str username: username. :param str password: password. """ languages = { Language.fromopensubtitles(l) for l in language_converters['opensubtitles'].codes } subtitle_class = OpenSubtitlesSubtitle 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 initialize(self): logger.info('Logging in') response = checked( self.server.LogIn(self.username, self.password, 'eng', 'subliminal v%s' % __short_version__)) self.token = response['token'] logger.debug('Logged in with token %r', self.token) def terminate(self): logger.info('Logging out') checked(self.server.LogOut(self.token)) self.server.close() self.token = None logger.debug('Logged out') def no_operation(self): logger.debug('No operation') checked(self.server.NoOperation(self.token)) def query(self, languages, hash=None, size=None, imdb_id=None, query=None, season=None, episode=None, tag=None): # fill the search criteria criteria = [] if hash and size: criteria.append({'moviehash': hash, 'moviebytesize': str(size)}) if imdb_id: criteria.append({'imdbid': imdb_id[2:]}) if tag: criteria.append({'tag': tag}) if query and season and episode: criteria.append({ 'query': query.replace('\'', ''), 'season': season, 'episode': episode }) elif query: criteria.append({'query': query.replace('\'', '')}) if not criteria: raise ValueError('Not enough information') # add the language for criterion in criteria: criterion['sublanguageid'] = ','.join( sorted(l.opensubtitles for l in languages)) # query the server logger.info('Searching subtitles %r', criteria) response = checked(self.server.SearchSubtitles(self.token, criteria)) subtitles = [] # exit if no data if not response['data']: logger.debug('No subtitles found') return subtitles # loop over subtitle items for subtitle_item in response['data']: # read the item language = Language.fromopensubtitles( subtitle_item['SubLanguageID']) hearing_impaired = bool(int(subtitle_item['SubHearingImpaired'])) page_link = subtitle_item['SubtitlesLink'] subtitle_id = int(subtitle_item['IDSubtitleFile']) matched_by = subtitle_item['MatchedBy'] movie_kind = subtitle_item['MovieKind'] hash = subtitle_item['MovieHash'] movie_name = subtitle_item['MovieName'] movie_release_name = subtitle_item['MovieReleaseName'] movie_year = int(subtitle_item['MovieYear'] ) if subtitle_item['MovieYear'] else None movie_imdb_id = 'tt' + subtitle_item['IDMovieImdb'] series_season = int(subtitle_item['SeriesSeason'] ) if subtitle_item['SeriesSeason'] else None series_episode = int(subtitle_item['SeriesEpisode'] ) if subtitle_item['SeriesEpisode'] else None filename = subtitle_item['SubFileName'] encoding = subtitle_item.get('SubEncoding') or None subtitle = self.subtitle_class(language, hearing_impaired, page_link, subtitle_id, matched_by, movie_kind, hash, movie_name, movie_release_name, movie_year, movie_imdb_id, series_season, series_episode, filename, encoding) logger.debug('Found subtitle %r by %s', subtitle, matched_by) subtitles.append(subtitle) return subtitles def list_subtitles(self, video, languages): season = episode = None if isinstance(video, Episode): query = video.series season = video.season episode = video.episode else: query = video.title return self.query(languages, hash=video.hashes.get('opensubtitles'), size=video.size, imdb_id=video.imdb_id, query=query, season=season, episode=episode, tag=os.path.basename(video.name)) def download_subtitle(self, subtitle): logger.info('Downloading subtitle %r', subtitle) response = checked( self.server.DownloadSubtitles(self.token, [str(subtitle.subtitle_id)])) subtitle.content = fix_line_ending( zlib.decompress(base64.b64decode(response['data'][0]['data']), 47))
def __dir__(self): try: return ServerProxy.__getattr__(self, 'system.listMethods')() except Fault as e: # Server doesn't provide method warn(str(e)) return []
class OpenSubtitlesProvider(Provider): languages = {Language.fromopensubtitles(l) for l in language_converters['opensubtitles'].codes} 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 initialize(self): logger.info('Logging in') response = checked(self.server.LogIn(self.username, self.password, 'eng', 'subliminal v%s' % __short_version__)) self.token = response['token'] logger.debug('Logged in with token %r', self.token) def terminate(self): logger.info('Logging out') checked(self.server.LogOut(self.token)) self.server.close() self.token = None logger.debug('Logged out') def no_operation(self): logger.debug('No operation') checked(self.server.NoOperation(self.token)) def query(self, languages, hash=None, size=None, imdb_id=None, query=None, season=None, episode=None, tag=None): # fill the search criteria criteria = [] if hash and size: criteria.append({'moviehash': hash, 'moviebytesize': str(size)}) if imdb_id: criteria.append({'imdbid': imdb_id[2:]}) if tag: criteria.append({'tag': tag}) if query and season and episode: criteria.append({'query': query.replace('\'', ''), 'season': season, 'episode': episode}) elif query: criteria.append({'query': query.replace('\'', '')}) if not criteria: raise ValueError('Not enough information') # add the language for criterion in criteria: criterion['sublanguageid'] = ','.join(sorted(l.opensubtitles for l in languages)) # query the server logger.info('Searching subtitles %r', criteria) response = checked(self.server.SearchSubtitles(self.token, criteria)) subtitles = [] # exit if no data if not response['data']: logger.debug('No subtitles found') return subtitles # loop over subtitle items for subtitle_item in response['data']: # read the item language = Language.fromopensubtitles(subtitle_item['SubLanguageID']) hearing_impaired = bool(int(subtitle_item['SubHearingImpaired'])) page_link = subtitle_item['SubtitlesLink'] subtitle_id = int(subtitle_item['IDSubtitleFile']) matched_by = subtitle_item['MatchedBy'] movie_kind = subtitle_item['MovieKind'] hash = subtitle_item['MovieHash'] movie_name = subtitle_item['MovieName'] movie_release_name = subtitle_item['MovieReleaseName'] movie_year = int(subtitle_item['MovieYear']) if subtitle_item['MovieYear'] else None movie_imdb_id = 'tt' + subtitle_item['IDMovieImdb'] series_season = int(subtitle_item['SeriesSeason']) if subtitle_item['SeriesSeason'] else None series_episode = int(subtitle_item['SeriesEpisode']) if subtitle_item['SeriesEpisode'] else None filename = subtitle_item['SubFileName'] encoding = subtitle_item.get('SubEncoding') or None subtitle = OpenSubtitlesSubtitle(language, hearing_impaired, page_link, subtitle_id, matched_by, movie_kind, hash, movie_name, movie_release_name, movie_year, movie_imdb_id, series_season, series_episode, filename, encoding) logger.debug('Found subtitle %r by %s', subtitle, matched_by) subtitles.append(subtitle) return subtitles def list_subtitles(self, video, languages): season = episode = None if isinstance(video, Episode): query = video.series season = video.season episode = video.episode else: query = video.title return self.query(languages, hash=video.hashes.get('opensubtitles'), size=video.size, imdb_id=video.imdb_id, query=query, season=season, episode=episode, tag=os.path.basename(video.name)) def download_subtitle(self, subtitle): logger.info('Downloading subtitle %r', subtitle) response = checked(self.server.DownloadSubtitles(self.token, [str(subtitle.subtitle_id)])) subtitle.content = fix_line_ending(zlib.decompress(base64.b64decode(response['data'][0]['data']), 47))
def sendNZB(nzb, proper=False): # pylint: disable=too-many-locals, too-many-statements, too-many-branches, too-many-return-statements """ Sends NZB to NZBGet client :param nzb: nzb object :param proper: True if this is a Proper download, False if not. Defaults to False """ if sickbeard.NZBGET_HOST is None: logger.log('No NZBget host found in configuration. Please configure it.', logger.WARNING) return False addToTop = False nzbgetprio = 0 category = sickbeard.NZBGET_CATEGORY if nzb.show.is_anime: category = sickbeard.NZBGET_CATEGORY_ANIME url = 'http{}://{}:{}@{}/xmlrpc'.format( 's' if sickbeard.NZBGET_USE_HTTPS else '', sickbeard.NZBGET_USERNAME, sickbeard.NZBGET_PASSWORD, sickbeard.NZBGET_HOST) nzbGetRPC = ServerProxy(url) try: if nzbGetRPC.writelog('INFO', 'SickRage connected to drop off {} any moment now.'.format(nzb.name + '.nzb')): logger.log('Successful connected to NZBget', logger.DEBUG) else: logger.log('Successful connected to NZBget, but unable to send a message', logger.WARNING) 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 dupekey = '' dupescore = 0 # if it aired recently make it high priority and generate DupeKey/Score for curEp in nzb.episodes: if dupekey == '': if curEp.show.indexer == 1: dupekey = 'SickRage-' + str(curEp.show.indexerid) elif curEp.show.indexer == 2: dupekey = 'SickRage-tvr' + str(curEp.show.indexerid) dupekey += '-' + str(curEp.season) + '.' + str(curEp.episode) if datetime.date.today() - curEp.airdate <= datetime.timedelta(days=7): addToTop = True nzbgetprio = sickbeard.NZBGET_PRIORITY else: category = sickbeard.NZBGET_CATEGORY_BACKLOG if nzb.show.is_anime: category = sickbeard.NZBGET_CATEGORY_ANIME_BACKLOG if nzb.quality != Quality.UNKNOWN: dupescore = nzb.quality * 100 if proper: dupescore += 10 nzbcontent64 = None if nzb.resultType == 'nzbdata': data = nzb.extraInfo[0] nzbcontent64 = standard_b64encode(data) logger.log('Sending NZB to NZBget') logger.log('URL: ' + url, logger.DEBUG) 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.resultType == 'nzb': if not nzb.provider.login(): return False data = nzb.provider.get_url(nzb.url, returns='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: logger.log('NZB sent to NZBget successfully', logger.DEBUG) return True else: logger.log('NZBget could not add {} to the queue'.format(nzb.name + '.nzb'), logger.WARNING) return False except Exception: logger.log('Connect Error to NZBget: could not add {} to the queue'.format(nzb.name + '.nzb'), logger.WARNING) return False
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')
#!/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!
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 __init__(self): self.server = ServerProxy('https://api.opensubtitles.org/xml-rpc', TimeoutSafeTransport(10)) self.token = None