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
