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, 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, **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, 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=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, 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, 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))