def __init__(self, port=8270, port_file=None):
SimpleXMLRPCServer.__init__(self, ('127.0.0.1', int(port)))
self.register_function(self.get_keyword_names)
self.register_function(self.get_keyword_documentation)
self.register_function(self.run_keyword)
announce_port(self.socket, port_file)
self.serve_forever()
def __init__(self, scripts=[], xmlport=port, kill=False, restart=False):
# Random port?
if xmlport is None:
xmlport = random.randint(1024,65000)
self.port = xmlport
# Create the RPC server
SimpleXMLRPCServer.__init__(self, (host, xmlport),
allow_none=True, logRequests=False)
# Create the logger
self.log = self.initializeLogging()
self.log.info("Listening on port %i" % xmlport)
# A listing of the filenames for each script
self.listOfScripts = []
# Keep list of all of the clients
self.clients = {0: sugarbotSession(0)}
# Misc other stuffs...
self.kill = kill
self.restart = restart
self.log.info("Kill: %s\tRestart: %s" % (kill,restart))
for script in scripts:
self.addScript(script)
# Register all of the functions so that callers can use them
self.registerFunctions()
# Initialize the random seed for generating client ID's
self.initRandomSeed()
def __init__(self, polling_interval, address_tuple, target, fake=False):
'''Constructor.
:param polling_interval: how frequently to poll.
:param address_tuple: the tuple (<ip address>, <port>).
:param target: the target logging system.
:param fake: whether or not to generate fake data.'''
SimpleXMLRPCServer.__init__(self, address_tuple)
self._polling_interval = polling_interval
if polling_interval < 1:
self._polling_interval = 1
self._target = target
self._fake = fake
self._running = False
self._last_update = time.time()
self._rates = dict()
self._capture_rate = 0
self._cstatistics = dict()
# Register external API handlers.
self.register_introspection_functions()
self.register_function(self.interface)
self.register_function(self.ethernet)
self.register_function(self.capture)
def __init__(self, *args, **kwargs):
"""
Takes the same arguments as SimpleXMLRPCServer, with the addition of
some keyward arguments documented here. All of the additional
arguments are passed directly into `ssl.wrap_socket`. For details, see
the documentation on `ssl.wrap_socket`.
:param certfile:
File with PEM formatted certificate.
:param keyfile:
File with PEM formatted private key. Not needed if certfile
contains private key.
:param cert_reqs:
Specifies whether a certificate is required from clients. Must be
one of `ssl.CERT_OPTIONAL`, `ssl.CERT_REQUIRED`, or
`ssl.CERT_NONE`. Default `ssl.CERT_REQUIRED`.
:param ca_certs:
File containing accepted "certification authority" certificates.
:param ssl_version:
SSL protocol version to use. Must be one of `ssl.PROTOCOL_*`.
Default `ssl.PROTOCOL_TLSv1`.
"""
self.keyfile = kwargs.pop("keyfile", None)
self.certfile = kwargs.pop("certfile", None)
self.cert_reqs = kwargs.pop("cert_reqs", ssl.CERT_REQUIRED)
self.ca_certs = kwargs.pop("ca_certs", None)
self.ssl_version = kwargs.pop("ssl_version", ssl.PROTOCOL_TLSv1)
SimpleXMLRPCServer.__init__(self, *args, **kwargs)
def __init__(self, path, requestHandler=AuthenticatedXMLRPCRequestHandler,
logRequests=1, ssl=False, sslCert=None):
self.sslCert = sslCert
self.ssl = ssl
SimpleXMLRPCServer.__init__(self, path, requestHandler, logRequests)
AuthenticatedXMLRPCDispatcher.__init__(self)
def __init__(self, *args, **kargs):
class RequestHandler(SimpleXMLRPCRequestHandler):
def _dispatch(self, method, params):
"""
Overridden to pass request handler to the handling function so that the function can play around
with HTTP headers and stuff
"""
params = (self, ) + params
func = None
try:
func = self.server.funcs[method]
except KeyError:
if self.server.instance is not None:
if hasattr(self.server.instance, '_dispatch'):
return self.server.instance._dispatch(method, params)
else:
try:
func = _resolve_dotted_attribute(self.server.instance, method)
except AttributeError:
pass
if func is not None:
return apply(func, params)
else:
raise Exception('method "%s" is not supported' % method)
SimpleXMLRPCServer.__init__(self, requestHandler=RequestHandler, *args, **kargs)
def __init__(self, host='127.0.0.1', port=8270):
SimpleXMLRPCServer.__init__(self, (host, int(port)),
logRequests=False,
allow_none=True,
encoding='utf-8')
self.register_function(self.run_method)
self.register_function(self.run_method_expression)
def __init__(self, addr, requestHandler=IPXMLRPCRequestHandler,
logRequests=True, allow_none=False, encoding=None,
bind_and_activate=True):
self.address_family = socket.getaddrinfo(*addr)[0][0]
SimpleXMLRPCServer.__init__(self, addr, requestHandler,
logRequests, allow_none, encoding,
bind_and_activate)
def __init__(self, addr, requestHandler=SecureXMLRPCRequestHandler,
logRequests=False, allow_none=False, encoding=None,
bind_and_activate=True, keyfile=None, certfile=None,
ca_certs=None):
SimpleXMLRPCServer.__init__(self, addr, requestHandler, logRequests,
allow_none, encoding, False)
if certfile and ((not os.path.exists(certfile)) or os.path.getsize(certfile) < 1):
raise Exception("certfile %s doesn't exist or is empty" % certfile)
if keyfile and ((not os.path.exists(keyfile)) or
os.path.getsize(keyfile) < 1):
raise Exception("keyfile %s doesn't exist or is empty" % keyfile)
self.socket = ssl.wrap_socket(self.socket,
keyfile=keyfile,
certfile=certfile,
server_side=True,
cert_reqs=ssl.CERT_REQUIRED,
# ssl_version=ssl.PROTOCOL_TLSv1,
ssl_version=ssl.PROTOCOL_SSLv23, # Ideally we'd accept any TLS but no SSL. Sigh.
ca_certs=ca_certs)
# ciphers='HIGH:MEDIUM:!ADH:!SSLv2:!MD5:!RC4:@STRENGTH') # Hopefully this effectively exclues SSLv2 and 3?
if bind_and_activate:
# This next throws a socket.error on error, eg
# Address already in use or Permission denied.
# Catch for clearer error message?
self.server_bind()
self.server_activate()
def __init__(self, session, sspec, handler):
SimpleXMLRPCServer.__init__(self, sspec[:2], handler)
self.daemon_threads = True
self.session = session
self.sessions = {}
self.session_cookie = None
# Duplicates from SocketServer.py, so our overrides work
self.__is_shut_down = threading.Event()
self.__shutdown_request = False
# This lets us create new HTTPDs withut waiting for this one to
# completely shut down.
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# We set a large sending buffer to avoid blocking, because the GIL and
# scheduling interact badly when we have busy background jobs.
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 128 * 1024)
self.server_url = 'http://UNKNOWN/'
self.sspec = (sspec[0]
or 'localhost', self.socket.getsockname()[1], sspec[2])
# This hash includes the index ofuscation master key, which means
# it should be very strongly unguessable.
self.secret = okay_random(64, session.config.get_master_key())
# Generate a new unguessable session cookie name on startup
while not self.session_cookie:
self.session_cookie = okay_random(12, self.secret)
def __init__(self, username, password, *args, **kargs):
self.username = username
self.password = password
# we use an inner class so that we can call out to the
# authenticate method
class VerifyingRequestHandler(SimpleXMLRPCRequestHandler):
# this is the method we must override
def parse_request(myself):
# first, call the original implementation which returns
# True if all OK so far
if SimpleXMLRPCRequestHandler.parse_request(myself):
# next we authenticate
if self.authenticate(myself.headers):
return True
else:
# if authentication fails, tell the client
myself.send_error(401, 'Authentication failed')
return False
# and intialise the superclass with the above
SimpleXMLRPCServer.__init__(self,
requestHandler=VerifyingRequestHandler,
logRequests=False,
*args,
**kargs)
def __init__(self, config, host="localhost", port=0, log_requests=False, verbose_queue=False):
SimpleXMLRPCServer.__init__(self, (host, port), allow_none=True, logRequests=log_requests)
self._host = host
self._verbose_queue = verbose_queue
# https: server.socket = ssl.wrap_socket(srv.socket, ...)
if isinstance(config, EnKFMain):
self._config = config
self._config_file = config.getUserConfigFile()
else:
if os.path.exists(config):
self._config = EnKFMain(config)
self._config_file = config
else:
raise IOError("The ert config file: %s does not exist" % config)
self._session = Session()
self.register_function(self.ertVersion)
self.register_function(self.getTimeMap)
self.register_function(self.isRunning)
self.register_function(self.isInitializationCaseAvailable)
self.register_function(self.startSimulationBatch)
self.register_function(self.addSimulation)
self.register_function(self.isRealizationFinished)
self.register_function(self.didRealizationSucceed)
self.register_function(self.didRealizationFail)
self.register_function(self.getGenDataResult)
self.register_function(self.getCustomKWResult)
self.register_function(self.isCustomKWKey)
self.register_function(self.isGenDataKey)
self.register_function(self.prototypeStorage)
self.register_function(self.storeGlobalData)
self.register_function(self.storeSimulationData)
def __init__(self, addr, requestHandler=KeepAliveRequestHandler,
logRequests=True, allow_none=True, encoding=None,
bind_and_activate=True, key_path='key.pem',
cert_path='cert.pem', ca_certs=None, cert_reqs=CERT_NONE,
ssl_version=PROTOCOL_SSLv23):
"""Overriding __init__ method of the SimpleXMLRPCServer to add SSL in
between basic init and network activation.
"""
# Initializing SecureXMLRPCServer *without* network
SimpleXMLRPCServer.__init__(self, addr, requestHandler=requestHandler,
logRequests=logRequests,
allow_none=allow_none, encoding=encoding,
bind_and_activate=False)
# Validate arguments possibly supplied by user
if not os.path.isfile(key_path):
raise ValueError("No such server key: %s" % key_path)
if not os.path.isfile(cert_path):
raise ValueError("No such server certificate: %s" % cert_path)
if not ssl_version in (PROTOCOL_SSLv23, PROTOCOL_TLSv1_2):
raise ValueError("Invalid ssl_version value: %s" % ssl_version)
if not cert_reqs in (CERT_NONE, CERT_OPTIONAL, CERT_REQUIRED):
raise ValueError("Invalid cert_reqs value: %s" % cert_reqs)
self.socket = wrap_socket(self.socket, server_side=True,
keyfile=key_path, certfile=cert_path,
cert_reqs=cert_reqs, ssl_version=ssl_version,
ca_certs=ca_certs)
if bind_and_activate:
self.server_bind()
self.server_activate()
def __init__(self, *args, **kwds):
"""
"""
SimpleXMLRPCServer.__init__(self, *args, **kwds)
self.api_key = None
self.pid = 1
self.jobs = {}
def __init__(self,
addr,
requestHandler=SecureXMLRPCRequestHandler,
logRequests=False,
allow_none=False,
encoding=None,
bind_and_activate=True,
keyfile=None,
certfile=None,
ca_certs=None):
SimpleXMLRPCServer.__init__(self, addr, requestHandler, logRequests,
allow_none, encoding, False)
if certfile and ((not os.path.exists(certfile))
or os.path.getsize(certfile) < 1):
raise Exception("certfile %s doesn't exist or is empty" % certfile)
if keyfile and ((not os.path.exists(keyfile))
or os.path.getsize(keyfile) < 1):
raise Exception("keyfile %s doesn't exist or is empty" % keyfile)
self.socket = ssl.wrap_socket(self.socket,
keyfile=keyfile,
certfile=certfile,
server_side=True,
cert_reqs=ssl.CERT_REQUIRED,
ssl_version=ssl.PROTOCOL_SSLv23,
ca_certs=ca_certs)
if bind_and_activate:
# This next throws a socket.error on error, eg
# Address already in use or Permission denied.
# Catch for clearer error message?
self.server_bind()
self.server_activate()
def __init__(self, dbfile, logfile, interface, daemon=True):
''' constructor '''
SimpleXMLRPCServer.__init__(self,
interface,
logRequests=False,
allow_none=True)
self.dbfile = dbfile
self.daemon = daemon
self.logfile = logfile
self.working_thread = None
self.host, self.port = self.socket.getsockname()
self.pidfile = PIDPREFIX % (self.host, self.port)
self.register_function(self.getPR, "getPR")
self.register_function(self.quit, "quit")
self.register_function(self.ping, "ping")
self.register_function(self.export, "export")
self.register_function(self.importone, "importone")
self.register_introspection_functions()
self.db = prserv.db.PRData(self.dbfile)
self.table = self.db["PRMAIN"]
self.requestqueue = Queue.Queue()
self.handlerthread = threading.Thread(
target=self.process_request_thread)
self.handlerthread.daemon = False
def __init__(self, uri, logRequests=False, allow_none=True, start=True):
if isinstance(uri,
basestring): # Allow http://domain.name:port definition
if uri[:8] != 'https://' and uri[:7] != 'http://':
raise Exception('url must start with http(s)://')
netloc = uri.split('//')[1]
if len(netloc.split('/')) != 1 or len(netloc.split(':')) != 2:
raise Exception(
'Did not understand {}. Expected http(s)://domain.name.com:port'
)
host, port = netloc.split(':')
port = int(port)
self.uri = uri
else:
host, port = uri # also allow SimpleXMLRPCServer-sytle (host,port) definition
self.uri = 'http://{}:{}'.format(host, port)
ags_log.info("Starting RPC Server on {}:{}".format(host, port))
SimpleXMLRPCServer.__init__(self, (host, port),
allow_none=allow_none,
logRequests=logRequests)
if start:
self.start()
def __init__(self, host=None, port=None, keyfile=None, certfile=None,
ca_certs=None, cert_reqs=ssl.CERT_NONE, ssl_version=ssl.PROTOCOL_TLSv1,
do_handshake_on_connect=True, suppress_ragged_eofs=True, ciphers=None,
log_requests=True, **kwargs):
SimpleXMLRPCServer.__init__(self, (host, port), requestHandler=RequestHandler)
self.logger = logging.getLogger(self.__class__.__name__)
self.keyfile = keyfile
self.certfile = certfile
self.ca_certs = ca_certs
self.cert_reqs = cert_reqs
self.ssl_version = ssl_version
self.do_handshake_on_connect = do_handshake_on_connect
self.suppress_ragged_eofs = suppress_ragged_eofs
self.ciphers = ciphers
# Looks awkward to use camelCase here but that's what SimpleXMLRPCRequestHandler
# expects.
self.logRequests = log_requests
# 'verify_fields' is taken from kwargs to allow for adding more keywords
# in future versions.
self.verify_fields = kwargs.get("verify_fields")
self.register_functions()
def __init__(self, port, interpreter):
address = ("localhost", port)
SimpleXMLRPCServer.__init__(self, address, logRequests=False, allow_none=True)
self.register_instance(self._methods(interpreter))
self.register_introspection_functions()
def __init__(self, addr, requestHandler=KeepAliveRequestHandler,
logRequests=True, allow_none=True, encoding=None,
bind_and_activate=True, key_path='key.pem',
cert_path='cert.pem', ca_certs=None, cert_reqs=CERT_NONE,
ssl_version=PROTOCOL_SSLv23):
"""Overriding __init__ method of the SimpleXMLRPCServer to add SSL in
between basic init and network activation.
"""
# Initializing SecureXMLRPCServer *without* network
SimpleXMLRPCServer.__init__(self, addr, requestHandler=requestHandler,
logRequests=logRequests,
allow_none=allow_none, encoding=encoding,
bind_and_activate=False)
# Validate arguments possibly supplied by user
if not os.path.isfile(key_path):
raise ValueError("No such server key: %s" % key_path)
if not os.path.isfile(cert_path):
raise ValueError("No such server certificate: %s" % cert_path)
if not ssl_version in (PROTOCOL_SSLv2, PROTOCOL_SSLv3, PROTOCOL_SSLv23,
PROTOCOL_TLSv1):
raise ValueError("Invalid ssl_version value: %s" % ssl_version)
if not cert_reqs in (CERT_NONE, CERT_OPTIONAL, CERT_REQUIRED):
raise ValueError("Invalid cert_reqs value: %s" % cert_reqs)
self.socket = wrap_socket(self.socket, server_side=True,
keyfile=key_path, certfile=cert_path,
cert_reqs=cert_reqs, ssl_version=ssl_version,
ca_certs=ca_certs)
if bind_and_activate:
self.server_bind()
self.server_activate()
def __init__(self, host=None, port=None, keyfile=None, certfile=None,
ca_certs=None, cert_reqs=ssl.CERT_NONE, ssl_version=ssl.PROTOCOL_TLSv1,
do_handshake_on_connect=True, suppress_ragged_eofs=True, ciphers=None,
log_requests=True, **kwargs):
SimpleXMLRPCServer.__init__(self, (host, port), requestHandler=RequestHandler)
self.logger = logging.getLogger(self.__class__.__name__)
self.keyfile = keyfile
self.certfile = certfile
self.ca_certs = ca_certs
self.cert_reqs = cert_reqs
self.ssl_version = ssl_version
self.do_handshake_on_connect = do_handshake_on_connect
self.suppress_ragged_eofs = suppress_ragged_eofs
self.ciphers = ciphers
# Looks awkward to use camelCase here but that's what SimpleXMLRPCRequestHandler
# expects.
self.logRequests = log_requests
# 'verify_fields' is taken from kwargs to allow for adding more keywords
# in future versions.
self.verify_fields = kwargs.get("verify_fields")
self.register_functions()
def __init__(self,
sspec,
boss,
handler=RequestHandler,
logger=Logger,
xmlrpc=None,
auth_handler=None,
ssl_pem_filename=None,
ssl_context=None):
SimpleXMLRPCServer.__init__(self, sspec, handler)
self.boss = boss
self.handler = handler
self.auth_handler = auth_handler
self.logger = logger()
if xmlrpc:
self.xmlrpc = xmlrpc(boss)
self.register_introspection_functions()
self.register_instance(self.xmlrpc)
else:
self.xmlrpc = None
if ssl_pem_filename and ssl_context:
ctx = ssl_context(socks.SSL.TLSv1_METHOD)
ctx.use_privatekey_file(ssl_pem_filename)
ctx.use_certificate_chain_file(ssl_pem_filename)
self.socket = socks.SSL_Connect(ctx,
socket.socket(
self.address_family,
self.socket_type),
server_side=True)
self.server_bind()
self.server_activate()
self.enable_ssl = True
else:
self.enable_ssl = False
def __init__(self, addr, requestHandler=SecureXMLRPCRequestHandler,
logRequests=False, allow_none=False, encoding=None,
bind_and_activate=True, keyfile=None, certfile=None,
ca_certs=None):
SimpleXMLRPCServer.__init__(self, addr, requestHandler, logRequests,
allow_none, encoding, False)
if certfile and ((not os.path.exists(certfile)) or os.path.getsize(certfile) < 1):
raise Exception("certfile %s doesn't exist or is empty" % certfile)
if keyfile and ((not os.path.exists(keyfile)) or
os.path.getsize(keyfile) < 1):
raise Exception("keyfile %s doesn't exist or is empty" % keyfile)
self.socket = ssl.wrap_socket(self.socket,
keyfile=keyfile,
certfile=certfile,
server_side=True,
cert_reqs=ssl.CERT_REQUIRED,
ssl_version=ssl.PROTOCOL_SSLv23,
ca_certs=ca_certs)
if bind_and_activate:
# This next throws a socket.error on error, eg
# Address already in use or Permission denied.
# Catch for clearer error message?
self.server_bind()
self.server_activate()
def __init__(self, **kw):
"""
Creates the xml-rpc server
Keywords:
- host - hostname to listen on for xml-rpc requests, default 127.0.0.1
- port - port to listen on for xml-rpc requests, default 19481
- fcpHost - hostname where FCP port is
- fcpPort - port where FCP port is
- verbosity - verbosity of output messages, 0 (silent) through 6 (noisy),
default 4. Refer verbosity constants in fcp module
"""
# create the server
host = kw.get('host', xmlrpcHost)
port = kw.get('port', xmlrpcPort)
SimpleXMLRPCServer.__init__(self, (host, port))
# create the fcp node interface
fcpHost = kw.get('fcpHost', node.defaultFCPHost)
fcpPort = kw.get('fcpPort', node.defaultFCPPort)
verbosity = kw.get('verbosity', node.SILENT)
self.node = node.FCPNode(host=fcpHost,
port=fcpPort,
verbosity=verbosity,
)
# create the request handler
hdlr = FreenetXMLRPCRequestHandler(self.node)
# link in the request handler object
self.register_instance(hdlr)
self.register_introspection_functions()
def __init__(self,
addr,
keyfile,
certfile,
ca_certs,
requestHandler=SimpleXMLRPCRequestHandler,
logRequests=True,
allow_none=False,
encoding=None,
bind_and_activate=True):
SimpleXMLRPCServer.__init__(self,
addr,
requestHandler=requestHandler,
logRequests=logRequests,
allow_none=allow_none,
encoding=encoding,
bind_and_activate=False)
cert_reqs = (ssl.CERT_NONE if ca_certs is None else ssl.CERT_REQUIRED)
self.socket = ssl.wrap_socket(self.socket,
keyfile=keyfile,
certfile=certfile,
ca_certs=ca_certs,
cert_reqs=cert_reqs,
ssl_version=ssl.PROTOCOL_TLSv1)
if bind_and_activate:
self.server_bind()
self.server_activate()
def __init__(self,
library,
host='127.0.0.1',
port=8270,
port_file=None,
allow_stop=True):
"""Configure and start-up remote server.
:param library: Test library instance or module to host.
:param host: Address to listen. Use ``'0.0.0.0'`` to listen
to all available interfaces.
:param port: Port to listen. Use ``0`` to select a free port
automatically. Can be given as an integer or as
a string.
:param port_file: File to write port that is used. ``None`` means
no such file is written.
:param allow_stop: Allow/disallow stopping the server using
``Stop Remote Server`` keyword.
"""
SimpleXMLRPCServer.__init__(self, (host, int(port)), logRequests=False)
self._library = library
self._allow_stop = allow_stop
self._shutdown = False
self._register_functions()
self._register_signal_handlers()
self._announce_start(port_file)
self.serve_forever()
def __init__(self, interface):
self.quit = False
SimpleXMLRPCServer.__init__(self,
interface,
requestHandler=SimpleXMLRPCRequestHandler,
logRequests=False,
allow_none=True)
def __init__(self, dbfile, logfile, interface, daemon=True):
''' constructor '''
try:
SimpleXMLRPCServer.__init__(self,
interface,
logRequests=False,
allow_none=True)
except socket.error:
ip = socket.gethostbyname(interface[0])
port = interface[1]
msg = "PR Server unable to bind to %s:%s\n" % (ip, port)
sys.stderr.write(msg)
raise PRServiceConfigError
self.dbfile = dbfile
self.daemon = daemon
self.logfile = logfile
self.working_thread = None
self.host, self.port = self.socket.getsockname()
self.pidfile = PIDPREFIX % (self.host, self.port)
self.register_function(self.getPR, "getPR")
self.register_function(self.quit, "quit")
self.register_function(self.ping, "ping")
self.register_function(self.export, "export")
self.register_function(self.importone, "importone")
self.register_introspection_functions()
self.db = prserv.db.PRData(self.dbfile)
self.table = self.db["PRMAIN"]
self.requestqueue = Queue.Queue()
self.handlerthread = threading.Thread(
target=self.process_request_thread)
self.handlerthread.daemon = False
def __init__(self):
SimpleXMLRPCServer.__init__(self, ("", 8001),
requestHandler=RequestHandler)
self.register_introspection_functions()
self.register_function(self.print_command)
# allow the server to be turned off
self.closed = False
def __init__(self, config, host="localhost", port=0, log_requests=False, verbose_queue=False):
SimpleXMLRPCServer.__init__(self, (host, port), allow_none=True, logRequests=log_requests)
self._host = host
self._verbose_queue = verbose_queue
# https: server.socket = ssl.wrap_socket(srv.socket, ...)
if isinstance(config, EnKFMain):
self._config = config
self._config_file = config.getUserConfigFile()
else:
if os.path.exists(config):
self._config = EnKFMain(config)
self._config_file = config
else:
raise IOError("The ert config file: %s does not exist" % config)
self._session = Session()
self.register_function(self.ertVersion)
self.register_function(self.getTimeMap)
self.register_function(self.isRunning)
self.register_function(self.isInitializationCaseAvailable)
self.register_function(self.startSimulationBatch)
self.register_function(self.addSimulation)
self.register_function(self.isRealizationFinished)
self.register_function(self.didRealizationSucceed)
self.register_function(self.didRealizationFail)
self.register_function(self.getGenDataResult)
self.register_function(self.getCustomKWResult)
self.register_function(self.isCustomKWKey)
self.register_function(self.isGenDataKey)
self.register_function(self.prototypeStorage)
self.register_function(self.storeGlobalData)
self.register_function(self.storeSimulationData)
def __init__(self,
enkf_main,
host="localhost",
port=0,
log_requests=False,
verbose_queue=False):
SimpleXMLRPCServer.__init__(self, (host, port),
allow_none=True,
logRequests=log_requests)
self.ert_version = ResVersion()
self._host = host
self._verbose_queue = verbose_queue
# https: server.socket = ssl.wrap_socket(srv.socket, ...)
self._init_enkf_main(enkf_main)
self._session = Session()
self.register_function(self.ertVersion)
self.register_function(self.getTimeMap)
self.register_function(self.isRunning)
self.register_function(self.isInitializationCaseAvailable)
self.register_function(self.startSimulationBatch)
self.register_function(self.addSimulation)
self.register_function(self.isRealizationFinished)
self.register_function(self.didRealizationSucceed)
self.register_function(self.didRealizationFail)
self.register_function(self.getGenDataResult)
self.register_function(self.getCustomKWResult)
self.register_function(self.isCustomKWKey)
self.register_function(self.isGenDataKey)
self.register_function(self.prototypeStorage)
self.register_function(self.storeGlobalData)
self.register_function(self.storeSimulationData)
def __init__(self, addr, requestHandler=IPXMLRPCRequestHandler,
logRequests=True, allow_none=False, encoding=None,
bind_and_activate=True):
self.address_family = socket.getaddrinfo(*addr)[0][0]
SimpleXMLRPCServer.__init__(self, addr, requestHandler,
logRequests, allow_none, encoding,
bind_and_activate)
def __init__(self,
addr,
requestHandler=SecureXMLRPCRequestHandler,
logRequests=False,
allow_none=False,
encoding=None,
bind_and_activate=True,
keyfile=None,
certfile=None,
ca_certs=None):
SimpleXMLRPCServer.__init__(self, addr, requestHandler, logRequests,
allow_none, encoding, False)
self.socket = ssl.wrap_socket(self.socket,
keyfile=keyfile,
certfile=certfile,
server_side=True,
cert_reqs=ssl.CERT_REQUIRED,
ssl_version=ssl.PROTOCOL_SSLv23,
ca_certs=ca_certs)
if bind_and_activate:
# This next throws a socket.error on error, eg
# Address already in use or Permission denied.
# Catch for clearer error message?
self.server_bind()
self.server_activate()
def __init__(self, *args, **kwargs):
"""
Takes the same arguments as SimpleXMLRPCServer, with the addition of
some keyward arguments documented here. All of the additional
arguments are passed directly into `ssl.wrap_socket`. For details, see
the documentation on `ssl.wrap_socket`.
:param certfile:
File with PEM formatted certificate.
:param keyfile:
File with PEM formatted private key. Not needed if certfile
contains private key.
:param cert_reqs:
Specifies whether a certificate is required from clients. Must be
one of `ssl.CERT_OPTIONAL`, `ssl.CERT_REQUIRED`, or
`ssl.CERT_NONE`. Default `ssl.CERT_REQUIRED`.
:param ca_certs:
File containing accepted "certification authority" certificates.
:param ssl_version:
SSL protocol version to use. Must be one of `ssl.PROTOCOL_*`.
Default `ssl.PROTOCOL_TLSv1`.
"""
self.keyfile = kwargs.pop("keyfile", None)
self.certfile = kwargs.pop("certfile", None)
self.cert_reqs = kwargs.pop("cert_reqs", ssl.CERT_REQUIRED)
self.ca_certs = kwargs.pop("ca_certs", None)
self.ssl_version = kwargs.pop("ssl_version", ssl.PROTOCOL_TLSv1)
SimpleXMLRPCServer.__init__(self, *args, **kwargs)
def __init__(self, address, temp, auth_handler):
# Keep a dictionary mapping file uuids to open file handles and a
# dictionary mapping temporary file's file uuids to their absolute paths.
self.file_paths = {}
self.file_handles = {}
self.temp = temp
self.auth_handler = auth_handler
# Register file-like RPC methods to allow for file transfer.
SimpleXMLRPCServer.__init__(
self,
address,
allow_none=True,
requestHandler=AuthenticatedXMLRPCRequestHandler,
logRequests=(self.verbose >= 1))
def wrap(command, func):
def inner(*args, **kwargs):
if self.verbose >= 1:
print "file_server: %s %s" % (command, args)
return func(*args, **kwargs)
return inner
for command in RemoteBundleClient.FILE_COMMANDS:
self.register_function(wrap(command, getattr(self, command)),
command)
def __init__(self, *args, **kargs):
class RequestHandler(SimpleXMLRPCRequestHandler):
def _dispatch(self, method, params):
"""
Overridden to pass request handler to the handling function so that the function can play around
with HTTP headers and stuff
"""
params = (self, ) + params
func = None
try:
func = self.server.funcs[method]
except KeyError:
if self.server.instance is not None:
if hasattr(self.server.instance, '_dispatch'):
return self.server.instance._dispatch(
method, params)
else:
try:
func = _resolve_dotted_attribute(
self.server.instance, method)
except AttributeError:
pass
if func is not None:
return apply(func, params)
else:
raise Exception('method "%s" is not supported' % method)
SimpleXMLRPCServer.__init__(self,
requestHandler=RequestHandler,
*args,
**kargs)
def __init__(self, dbfile, logfile, interface, daemon=True):
''' constructor '''
try:
SimpleXMLRPCServer.__init__(self, interface,
logRequests=False, allow_none=True)
except socket.error:
ip=socket.gethostbyname(interface[0])
port=interface[1]
msg="PR Server unable to bind to %s:%s\n" % (ip, port)
sys.stderr.write(msg)
raise PRServiceConfigError
self.dbfile=dbfile
self.daemon=daemon
self.logfile=logfile
self.working_thread=None
self.host, self.port = self.socket.getsockname()
self.pidfile=PIDPREFIX % (self.host, self.port)
self.register_function(self.getPR, "getPR")
self.register_function(self.quit, "quit")
self.register_function(self.ping, "ping")
self.register_function(self.export, "export")
self.register_function(self.importone, "importone")
self.register_introspection_functions()
self.db = prserv.db.PRData(self.dbfile)
self.table = self.db["PRMAIN"]
self.requestqueue = Queue.Queue()
self.handlerthread = threading.Thread(target = self.process_request_thread)
self.handlerthread.daemon = False
def __init__(self, port=8270, port_file=None):
SimpleXMLRPCServer.__init__(self, ('127.0.0.1', int(port)))
self.register_function(self.get_keyword_names)
self.register_function(self.get_keyword_documentation)
self.register_function(self.run_keyword)
announce_port(self.socket, port_file)
self.serve_forever()
def __init__(self, sspec, boss,
handler=RequestHandler,
logger=Logger,
xmlrpc=None,
auth_handler=None,
ssl_pem_filename=None,
ssl_context=None):
SimpleXMLRPCServer.__init__(self, sspec, handler)
self.boss = boss
self.handler = handler
self.auth_handler = auth_handler
self.logger = logger()
if xmlrpc:
self.xmlrpc = xmlrpc(boss)
self.register_introspection_functions()
self.register_instance(self.xmlrpc)
else:
self.xmlrpc = None
if ssl_pem_filename and ssl_context:
ctx = ssl_context(socks.SSL.TLSv1_METHOD)
ctx.use_privatekey_file (ssl_pem_filename)
ctx.use_certificate_chain_file(ssl_pem_filename)
self.socket = socks.SSL_Connect(ctx, socket.socket(self.address_family,
self.socket_type),
server_side=True)
self.server_bind()
self.server_activate()
self.enable_ssl = True
else:
self.enable_ssl = False
def __init__(self):
SimpleXMLRPCServer.__init__(self, ("localhost", 8080),
requestHandler=RequestHandler)
self.register_function(self.new_system_user_pass,
"registration.new_system_user_pass")
self.register_function(self.refresh_hw_profile,
"registration.refresh_hw_profile")
self.register_function(self.virt_notify, "registration.virt_notify")
def __init__(self):
SimpleXMLRPCServer.__init__(self, ("192.168.235.168", 6666),
requestHandler=RequestHandler,
logRequests=False)
self.register_introspection_functions()
self.register_function(self.xmlrpc_contestants, "listContestants")
self.register_function(self.xmlrpc_get_position_stats, "getStats")
def __init__(self, host, port, sslcert=None, sslkey=None):
SimpleXMLRPCServer.__init__(self,
(host, port),
logRequests=False,
allow_none=True)
self._sslcert = sslcert
self._sslkey = sslkey
def __init__(self, library, host='localhost', port=8270, allow_stop=True):
SimpleXMLRPCServer.__init__(self, (host, int(port)), logRequests=False)
self._library = library
self._allow_stop = allow_stop
self._register_functions()
self._register_signal_handlers()
self._log('Robot Framework remote server starting at %s:%s' % (host, port))
self.serve_forever()
def __init__(self, addr, storage):
"""Loads the initial tbx file from the given filename"""
SimpleXMLRPCServer.__init__(self, addr, requestHandler=lookupRequestHandler, logRequests=1)
self.storage = storage
self.storage.makeindex()
self.matcher = match.matcher(storage)
print "Performing lookup from %d units" % len(storage.units)
print "Translation memory using %d units" % len(self.matcher.candidates.units)
def __init__(self, addr,
requestHandler=SimpleXMLRPCRequestHandler,
bind_and_activate=True,
allow_none=False):
SimpleXMLRPCServer.__init__(self, addr,
requestHandler=requestHandler,
bind_and_activate=bind_and_activate,
allow_none=allow_none)
def __init__(self, port, interpreter):
address = ('localhost', port)
SimpleXMLRPCServer.__init__(self, address,
logRequests=False, allow_none=True)
self.register_instance(self._methods(interpreter))
self.register_introspection_functions()
def __init__(self, host, port, port_file=None, allow_remote_stop=True):
SimpleXMLRPCServer.__init__(self, (host, port), logRequests=False,
bind_and_activate=False)
self._port_file = port_file
self._thread = None
self._allow_remote_stop = allow_remote_stop
self._stop_serve = None
self._stop_lock = threading.Lock()
def __init__(self, path, requestHandler=DelayableXMLRPCRequestHandler,
logRequests=1, ssl=False, sslCert=None, caCert=None):
self.sslCert = sslCert
self.caCert = caCert
self.ssl = ssl
SimpleXMLRPCServer.__init__(self, path, requestHandler, logRequests)
DelayableXMLRPCDispatcher.__init__(self)
def __init__(self, main, section, handlerClass=XMLRPCRequestHandler):
WebServerStub.__init__(self, main, section)
SimpleXMLRPCServer.__init__(self,
addr=(self.bindAddress, self.bindPort),
requestHandler=handlerClass,
logRequests=(Log.verbose >= 3),
allow_none=False,
encoding=None)
def __init__(self, host="127.0.0.1", port=5021):
SimpleXMLRPCServer.__init__(self, (host, port), allow_none=True)
self.register_instance(ImageManipulations())
self.register_multicall_functions()
self.register_introspection_functions()
print "Started XML-RPC server at %s:%d" % (host, port)
def __init__(self, session, sspec, handler):
SimpleXMLRPCServer.__init__(self, sspec, handler)
self.session = session
self.sessions = {}
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.sspec = (sspec[0] or "localhost", self.socket.getsockname()[1])
# FIXME: This could be more securely random
self.secret = "-".join([str(x) for x in [self.socket, self.sspec, time.time(), self.session]])
def __init__(self, host, ports,
requestHandler=SimpleXMLRPCRequestHandler,
logRequests=False, allow_none=False, encoding=None):
baseSocketServer.__init__(self, host, ports)
SimpleXMLRPCServer.__init__(self, self.server_address, requestHandler,
logRequests)
self.register_function(self.stop, 'stop')
def __init__(self, addr, requestHandler=KeepAliveRequestHandler,
logRequests=True, allow_none=False, encoding=None,
bind_and_activate=True):
SimpleXMLRPCServer.__init__(self, addr,
requestHandler=requestHandler,
logRequests=logRequests,
allow_none=allow_none,
encoding=encoding,
bind_and_activate=bind_and_activate)
def __init__(self, addr, requestHandler=SimpleXMLRPCRequestHandler,
logRequests=True, allow_none=False, encoding=None, bind_and_activate=True):
self.requestHandler = SimpleXMLRPCRequestHandler
self.requestHandler.rpc_paths = ['/', '/RPC2']
SimpleXMLRPCServer.__init__(self, addr, requestHandler, logRequests, allow_none,
encoding, bind_and_activate)
self.dispatchers = {}
self.allow_none = allow_none
self.encoding = encoding
def __init__(self, interface):
SimpleXMLRPCServer.__init__(self, interface, logRequests=False, allow_none=True)
self.register_function(self.registerEventHandler, "registerEventHandler")
self.register_function(self.unregisterEventHandler, "unregisterEventHandler")
self.register_function(self.terminateServer, "terminateServer")
#self.register_function(self.runCommand, "runCommand")
self.quit = False
self.clients = {}
self.client_ui_ids = {}
def __init__(self, library, port=8270, port_file=None):
SimpleXMLRPCServer.__init__(self, ('127.0.0.1', int(port)))
self.library = library
self._shutdown = False
self.register_function(self.get_keyword_names)
self.register_function(self.get_keyword_arguments)
self.register_function(self.run_keyword)
announce_port(self.socket, port_file)
self.serve_forever()
def __init__(self, session, sspec, handler):
SimpleXMLRPCServer.__init__(self, sspec, handler)
self.session = session
self.sessions = {}
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.sspec = (sspec[0] or 'localhost', self.socket.getsockname()[1])
# FIXME: This could be more securely random
self.secret = '-'.join([str(x) for x in [self.socket, self.sspec,
time.time(), self.session]])
def __init__(self, fs, addr, requestHandler=None, logRequests=None):
kwds = dict(allow_none=True)
if requestHandler is not None:
kwds['requestHandler'] = requestHandler
if logRequests is not None:
kwds['logRequests'] = logRequests
self.serve_more_requests = True
SimpleXMLRPCServer.__init__(self,addr,**kwds)
self.register_instance(RPCFSInterface(fs))
