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,
paramSource,
resultSinc,
barFeed,
address,
port,
autoStop=True):
SimpleXMLRPCServer.__init__(self, (address, port),
requestHandler=RequestHandler,
logRequests=False,
allow_none=True)
# super(Server, self).__init__((address, port), requestHandler=RequestHandler, logRequests=False, allow_none=True)
self.__paramSource = paramSource
self.__resultSinc = resultSinc
self.__barFeed = barFeed
self.__instrumentsAndBars = None # Pickle'd instruments and bars for faster retrieval.
self.__barsFreq = None
self.__activeJobs = {}
self.__activeJobsLock = threading.Lock()
self.__forcedStop = False
self.__bestResult = None
if autoStop:
self.__autoStopThread = AutoStopThread(self)
else:
self.__autoStopThread = None
self.register_introspection_functions()
self.register_function(self.getInstrumentsAndBars,
'getInstrumentsAndBars')
self.register_function(self.getBarsFrequency, 'getBarsFrequency')
self.register_function(self.getNextJob, 'getNextJob')
self.register_function(self.pushJobResults, 'pushJobResults')
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_functions()
announce_port(self.socket, port_file)
self.serve_forever()
def __init__(self, interface, single_use=False, idle_timeout=0):
"""
Constructor
"""
BaseImplServer.__init__(self)
self.single_use = single_use
# Use auto port configuration
if (interface[1] == -1):
interface = (interface[0], 0)
SimpleXMLRPCServer.__init__(self,
interface,
requestHandler=BitBakeXMLRPCRequestHandler,
logRequests=False,
allow_none=True)
self.host, self.port = self.socket.getsockname()
self.connection_token = None
#self.register_introspection_functions()
self.commands = BitBakeServerCommands(self)
self.autoregister_all_functions(self.commands, "")
self.interface = interface
self.time = time.time()
self.idle_timeout = idle_timeout
if idle_timeout:
self.register_idle_function(self.handle_idle_timeout, self)
self.heartbeat_seconds = 1 # default, BB_HEARTBEAT_EVENT will be checked once we have a datastore.
self.next_heartbeat = time.time()
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, dbfile, logfile, interface):
''' 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.logfile = logfile
self.host, self.port = self.socket.getsockname()
self.register_function(self.getPR, "getPR")
self.register_function(self.ping, "ping")
self.register_function(self.export, "export")
self.register_function(self.importone, "importone")
self.register_introspection_functions()
self.iter_count = 0
# 60 iterations between syncs or sync if dirty every ~30 seconds
self.iterations_between_sync = 60
def __init__(self, addr, log_requests=1):
"""
Overrides SimpleXMLRPCServer to set option to allow_reuse_address.
"""
# allow_reuse_address defaults to False in Python 2.4. We set it
# to True to allow quick restart on the same port. This is equivalent
# to calling setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
self.allow_reuse_address = True
# Increase request_queue_size to handle issues with many simultaneous
# connections in OSX 10.11
self.request_queue_size = min(socket.SOMAXCONN, 128)
if rosgraph.network.use_ipv6():
logger = logging.getLogger('xmlrpc')
# The XMLRPC library does not support IPv6 out of the box
# We have to monipulate private members and duplicate
# code from the constructor.
# TODO IPV6: Get this into SimpleXMLRPCServer
SimpleXMLRPCServer.__init__(self,
addr,
IPSilenceableXMLRPCRequestHandler,
log_requests,
bind_and_activate=False)
self.address_family = socket.AF_INET6
self.socket = socket.socket(self.address_family, self.socket_type)
logger.info('binding ipv6 xmlrpc socket to' + str(addr))
# TODO: set IPV6_V6ONLY to 0:
# self.socket.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)
self.server_bind()
self.server_activate()
logger.info('bound to ' + str(self.socket.getsockname()[0:2]))
else:
SimpleXMLRPCServer.__init__(self, addr,
IPSilenceableXMLRPCRequestHandler,
log_requests)
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.dump_db, "dump_db")
self.register_function(self.importone, "importone")
self.register_introspection_functions()
self.quitpipein, self.quitpipeout = os.pipe()
self.requestqueue = queue.Queue()
self.handlerthread = threading.Thread(
target=self.process_request_thread)
self.handlerthread.daemon = False
def __init__(self, addr, log_requests=1):
"""
Overrides SimpleXMLRPCServer to set option to allow_reuse_address.
"""
# allow_reuse_address defaults to False in Python 2.4. We set it
# to True to allow quick restart on the same port. This is equivalent
# to calling setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
self.allow_reuse_address = True
if rosgraph.network.use_ipv6():
logger = logging.getLogger('xmlrpc')
# The XMLRPC library does not support IPv6 out of the box
# We have to monipulate private members and duplicate
# code from the constructor.
# TODO IPV6: Get this into SimpleXMLRPCServer
SimpleXMLRPCServer.__init__(self, addr, SilenceableXMLRPCRequestHandler, log_requests, bind_and_activate=False)
self.address_family = socket.AF_INET6
self.socket = socket.socket(self.address_family, self.socket_type)
logger.info('binding ipv6 xmlrpc socket to' + str(addr))
# TODO: set IPV6_V6ONLY to 0:
# self.socket.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)
self.server_bind()
self.server_activate()
logger.info('bound to ' + str(self.socket.getsockname()[0:2]))
# TODO IPV6: check Windows compatibility
# [Bug #1222790] If possible, set close-on-exec flag; if a
# method spawns a subprocess, the subprocess shouldn't have
# the listening socket open.
if fcntl is not None and hasattr(fcntl, 'FD_CLOEXEC'):
flags = fcntl.fcntl(self.fileno(), fcntl.F_GETFD)
flags |= fcntl.FD_CLOEXEC
fcntl.fcntl(self.fileno(), fcntl.F_SETFD, flags)
else:
SimpleXMLRPCServer.__init__(self, addr, SilenceableXMLRPCRequestHandler, log_requests)
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, public_key, *args, private_key=None, requesthandler=SignedRequestHandler, allow_none=True, **kw):
SimpleXMLRPCServer.__init__(self, *args, requesthandler, allow_none, **kw)
self.stopped = False
self.public_key = public_key
self.private_key = private_key
self.register_function(lambda: 'pong', 'ping')
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_functions()
announce_port(self.socket, port_file)
self.serve_forever()
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.dump_db, "dump_db")
self.register_function(self.importone, "importone")
self.register_introspection_functions()
self.requestqueue = queue.Queue()
self.handlerthread = threading.Thread(target = self.process_request_thread)
self.handlerthread.daemon = False
def __init__(self, addr, log_requests=1):
"""
Overrides SimpleXMLRPCServer to set option to allow_reuse_address.
"""
# allow_reuse_address defaults to False in Python 2.4. We set it
# to True to allow quick restart on the same port. This is equivalent
# to calling setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
self.allow_reuse_address = True
if rosgraph.network.use_ipv6():
logger = logging.getLogger('xmlrpc')
# The XMLRPC library does not support IPv6 out of the box
# We have to monipulate private members and duplicate
# code from the constructor.
# TODO IPV6: Get this into SimpleXMLRPCServer
SimpleXMLRPCServer.__init__(self, addr, SilenceableXMLRPCRequestHandler, log_requests, bind_and_activate=False)
self.address_family = socket.AF_INET6
self.socket = socket.socket(self.address_family, self.socket_type)
logger.info('binding ipv6 xmlrpc socket to' + str(addr))
# TODO: set IPV6_V6ONLY to 0:
# self.socket.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)
self.server_bind()
self.server_activate()
logger.info('bound to ' + str(self.socket.getsockname()[0:2]))
else:
SimpleXMLRPCServer.__init__(self, addr, SilenceableXMLRPCRequestHandler, log_requests)
def __init__(self, interface):
self.quit = False
SimpleXMLRPCServer.__init__(self,
interface,
requestHandler=SimpleXMLRPCRequestHandler,
logRequests=False,
allow_none=True,
use_builtin_types=True)
def __init__(self, host, port):
SimpleXMLRPCServer.__init__(
self, (host, port),
requestHandler=MatchAllXMLRPCRequestHandler,
logRequests=False,
bind_and_activate=False)
self._activated = False
self._stopper_thread = None
def __init__(self, addr, log_requests=1):
"""
Overrides SimpleXMLRPCServer to set option to allow_reuse_address.
"""
# allow_reuse_address defaults to False in Python 2.4. We set it
# to True to allow quick restart on the same port. This is equivalent
# to calling setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
self.allow_reuse_address = True
SimpleXMLRPCServer.__init__(self, addr, SilenceableXMLRPCRequestHandler, log_requests)
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))
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, addr, log_requests=1):
"""
Overrides SimpleXMLRPCServer to set option to allow_reuse_address.
"""
# allow_reuse_address defaults to False in Python 2.4. We set it
# to True to allow quick restart on the same port. This is equivalent
# to calling setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
self.allow_reuse_address = True
SimpleXMLRPCServer.__init__(self, addr, SilenceableXMLRPCRequestHandler, log_requests)
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,
addr,
log=None,
requestHandler=SAMPSimpleXMLRPCRequestHandler,
logRequests=True,
allow_none=True,
encoding=None):
self.log = log
SimpleXMLRPCServer.__init__(self, addr, requestHandler, logRequests,
allow_none, encoding)
def __init__(self, bind_address, bind_port=61209,
requestHandler=GlancesXMLRPCHandler):
try:
self.address_family = socket.getaddrinfo(bind_address, bind_port)[0][0]
except socket.error as e:
logger.error("Couldn't open socket: {0}".format(e))
sys.exit(1)
SimpleXMLRPCServer.__init__(self, (bind_address, bind_port),
requestHandler)
def __init__(
self,
addr,
log=None,
requestHandler=SAMPSimpleXMLRPCRequestHandler,
logRequests=True,
allow_none=True,
encoding=None,
):
self.log = log
SimpleXMLRPCServer.__init__(self, addr, requestHandler, logRequests, allow_none, encoding)
def __init__(self, *args, **kwargs):
class AuthRequestHandler(SimpleXMLRPCRequestHandler):
def parse_request(myself):
if SimpleXMLRPCRequestHandler.parse_request(myself):
if self.authenticate(myself.headers):
return True
else:
myself.send_error(401, "Authentication failure")
return False
SimpleXMLRPCServer.__init__(self, requestHandler=AuthRequestHandler,
*args, **kwargs
)
def __init__(self, host, port, username, password, *args, **kwargs):
self.username = username
self.password = password
class RequestHandler(SimpleXMLRequestHandler):
def parse_request(request):
if SimpleXMLRequestHandler:
parse_request(request)
if self.authenticate(request.headers):
return True
else:
request.send_error(401, 'Authentication Failed')
return False
SimpleXMLRPCServer.__init__(self, (host, port), requestHandler=RequestHandler, *args, **kwargs)
def __init__(self, session, address='127.0.0.1', port=42184, timeout=10):
self.session = session # ChimeraX Session object
# start XML-RPC server
SimpleXMLRPCServer.__init__(self, (address, port), logRequests=0)
self.socket.settimeout(timeout)
session.logger.info("xmlrpc server running at %s on port %d" %
(address, port))
# Handle RPC calls once every frame draw
self._handler = session.triggers.add_handler('new frame',
self.process_requests)
def __init__(self):
SimpleXMLRPCServer.__init__(self, ("localhost", 9100))
self.__thread = None
self.__proxy = DRatsPluginProxy()
self.register_function(self.__proxy.send_chat, "send_chat")
self.register_function(self.__proxy.list_ports, "list_ports")
self.register_function(self.__proxy.send_file, "send_file")
self.register_function(self.__proxy.submit_rpcjob, "submit_rpcjob")
self.register_function(self.__proxy.get_result, "get_result")
self.register_function(self.__proxy.wait_for_chat, "wait_for_chat")
def __init__(self, *args, **kwargs):
class AuthRequestHandler(SimpleXMLRPCRequestHandler):
def parse_request(myself):
if SimpleXMLRPCRequestHandler.parse_request(myself):
if self.authenticate(myself.headers):
return True
else:
myself.send_error(401, "Authentication failure")
return False
SimpleXMLRPCServer.__init__(self,
requestHandler=AuthRequestHandler,
*args,
**kwargs)
def __init__(self,
bind_address,
bind_port=61209,
requestHandler=GlancesXMLRPCHandler):
try:
self.address_family = socket.getaddrinfo(bind_address,
bind_port)[0][0]
except socket.error as e:
logger.error("Couldn't open socket: {0}".format(e))
sys.exit(1)
SimpleXMLRPCServer.__init__(self, (bind_address, bind_port),
requestHandler)
def __init__(self, connection, headers, tenant_id):
SimpleXMLRPCServer.__init__(self, ("localhost", 8000))
self.tenant_id = tenant_id
self.every = DEFAULT_PERIOD
self.connection = connection
self.headers = headers
self.xmlrpc_url = "http://127.0.0.1:8000/RPC2"
self.worker = None
# register callback
self.wtp_up(callback=self.wtp_up_callback)
def __init__(self,host,port,username,password,*args,**kargs):
self.username = username
self.password = password
class VerifyingRequestHandler(SimpleXMLRPCRequestHandler):
def parse_request(request):
if SimpleXMLRPCRequestHandler.parse_request(request):
if self.authenticate(request.headers):
return True
else:
request.send_error(401,'Authentication failed,try again')
return False
SimpleXMLRPCServer.__init__(self,(host,port),requestHandler = VerifyingRequestHandler,*args,**kargs)
def __init__(self, interface, cooker, parent):
# Use auto port configuration
if (interface[1] == -1):
interface = (interface[0], 0)
SimpleXMLRPCServer.__init__(self, interface,
requestHandler=BitBakeXMLRPCRequestHandler,
logRequests=False, allow_none=True)
self.host, self.port = self.socket.getsockname()
self.interface = interface
self.connection_token = None
self.commands = BitBakeXMLRPCServerCommands(self)
self.register_functions(self.commands, "")
self.cooker = cooker
self.parent = parent
def __init__(self, interface, cooker, parent):
# Use auto port configuration
if (interface[1] == -1):
interface = (interface[0], 0)
SimpleXMLRPCServer.__init__(self, interface,
requestHandler=BitBakeXMLRPCRequestHandler,
logRequests=False, allow_none=True)
self.host, self.port = self.socket.getsockname()
self.interface = interface
self.connection_token = None
self.commands = BitBakeXMLRPCServerCommands(self)
self.register_functions(self.commands, "")
self.cooker = cooker
self.parent = parent
def __init__(self, bind_address, bind_port, requestHandler):
# IPv6 is supported
self.address_family = socket.getaddrinfo(bind_address, bind_port)[0][0]
SimpleXMLRPCServer.__init__(self, (bind_address, bind_port),
requestHandler,
logRequests=False)
self.socket = ssl.wrap_socket(socket.socket(self.address_family,
self.socket_type),
server_side=True,
certfile=CERTFILE,
keyfile=KEYFILE,
cert_reqs=ssl.CERT_NONE,
ssl_version=ssl.PROTOCOL_TLSv1_2,
do_handshake_on_connect=False)
self.server_bind()
self.server_activate()
def __init__(self):
# super(ThreadedRpcServer, self).__init__()
self.conn = None
self.cursor = None
self.datastrings_conn = None
self.datastrings_cursor = None
self.sensorsdb_name = None
self.sensorsdb_path = None
self.ext_wheelhouse_db_alias = 'extwheelhousedb'
if os.path.exists(os.path.join(os.getcwd(), '../data', DB_NAME)):
db_root_path = '../data'
elif os.path.exists(os.path.join(os.getcwd(), 'data', DB_NAME)):
db_root_path = 'data'
else:
logging.info(f"RpcServer: error connecting to the database")
return
db_full_path = os.path.join(db_root_path, DB_NAME)
self.conn = sqlite.Connection(db_full_path)
self.conn.setbusytimeout(5000)
self.cursor = self.conn.cursor()
sql = """
SELECT PARAMETER, VALUE FROM SETTINGS
WHERE PARAMETER IN ('FPC IP Address', 'Test FPC IP Address');
"""
self.cursor.execute(sql)
results = self.cursor.fetchall()
db_addresses = {}
if results:
db_addresses = {x[0]: x[1] for x in results}
self._hostname = get_fpc_ip(db_addresses)
logging.info(f"RpcServer: IP Address: {self._hostname}")
self._port = 9000
SimpleXMLRPCServer.__init__(self,
addr=(self._hostname, self._port),
requestHandler=RequestHandler,
logRequests=False,
allow_none=True,
use_builtin_types=True)
def __init__(self, sspec, pkite, conns,
handler=UiRequestHandler,
ssl_pem_filename=None):
SimpleXMLRPCServer.__init__(self, sspec, handler)
self.pkite = pkite
self.conns = conns
self.secret = pkite.ConfigSecret()
self.server_name = sspec[0]
self.server_port = sspec[1]
if ssl_pem_filename:
ctx = socks.SSL.Context(socks.SSL.TLSv1_METHOD)
ctx.set_cipher_list('HIGH:!MEDIUM:!LOW:!aNULL:!NULL:!SHA')
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
try:
from pagekite import yamond
gYamon = common.gYamon = yamond.YamonD(sspec)
gYamon.vset('started', int(time.time()))
gYamon.vset('version', APPVER)
gYamon.vset('httpd_ssl_enabled', self.enable_ssl)
gYamon.vset('errors', 0)
gYamon.lcreate("tunnel_rtt", 100)
gYamon.lcreate("tunnel_wrtt", 100)
gYamon.lists['buffered_bytes'] = [1, 0, common.buffered_bytes]
gYamon.views['selectables'] = (selectables.SELECTABLES, {
'idle': [0, 0, self.conns.idle],
'conns': [0, 0, self.conns.conns]
})
except:
pass
self.RCI = RemoteControlInterface(self, pkite, conns)
self.register_introspection_functions()
self.register_instance(self.RCI)
def __init__(self, interface, single_use=False):
"""
Constructor
"""
BaseImplServer.__init__(self)
self.single_use = single_use
# Use auto port configuration
if (interface[1] == -1):
interface = (interface[0], 0)
SimpleXMLRPCServer.__init__(self, interface,
requestHandler=BitBakeXMLRPCRequestHandler,
logRequests=False, allow_none=True)
self.host, self.port = self.socket.getsockname()
self.connection_token = None
#self.register_introspection_functions()
self.commands = BitBakeServerCommands(self)
self.autoregister_all_functions(self.commands, "")
self.interface = interface
def __init__(self, serverConfig):
self.config = serverConfig
SimpleXMLRPCServer.__init__(self, (self.config.server.hostname, \
self.config.server.port))
self.logger = logging.getLogger("xmlrpcserver::%s:%s" % (\
self.config.server.hostname, self.config.server.port))
self.logger.setLevel(logging.INFO)
lh = logging.StreamHandler()
lh.setLevel(logging.INFO)
formatter = logging.Formatter('%(asctime)s::%(name)s::%(message)s')
lh.setFormatter(formatter)
self.logger.addHandler(lh)
self.methodHelpList = {}
self.methodSignatureList = {}
self._parserHelpFile()
def __init__(self,
host='localhost',
port=4966,
logRequests=False,
allow_none=True,
keepalive_time=3 * 24 * 3600):
self.out_buffer = []
self.larch = Interpreter(writer=self)
self.larch.input.prompt = ''
self.larch.input.prompt2 = ''
self.larch.run_init_scripts()
self.larch('_sys.client = group(keepalive_time=%f)' % keepalive_time)
self.larch('_sys.wx = group(wxapp=None)')
_sys = self.larch.symtable._sys
_sys.color_exceptions = False
_sys.client.last_event = int(time())
_sys.client.pid_server = int(os.getpid())
_sys.client.app = 'unknown'
_sys.client.pid = 0
_sys.client.user = '******'
_sys.client.machine = socket.getfqdn()
self.client = self.larch.symtable._sys.client
self.port = port
SimpleXMLRPCServer.__init__(self, (host, port),
logRequests=logRequests,
allow_none=allow_none)
self.register_introspection_functions()
self.register_function(self.larch_exec, 'larch')
for method in ('ls', 'chdir', 'cd', 'cwd', 'shutdown',
'set_keepalive_time', 'set_client_info',
'get_client_info', 'get_data', 'get_rawdata',
'get_messages', 'len_messages'):
self.register_function(getattr(self, method), method)
# sys.stdout = self
self.finished = False
signal.signal(signal.SIGINT, self.signal_handler)
self.activity_thread = Thread(target=self.check_activity)
def __init__(self, handler, certFile=None, port=None):
if not certFile:
certFile = SettingsProvider.get_instance().readsetting(
'httpscertpath')
if not port:
port = int(
SettingsProvider.get_instance().readsetting('listenporthttps'))
HTTPServer.__init__(
self,
('0.0.0.0', port),
handler,
)
SimpleXMLRPCServer.__init__(self, ('0.0.0.0', port),
handler,
allow_none=True)
self.socket = ssl.wrap_socket(self.socket,
server_side=True,
certfile=certFile,
keyfile=certFile,
ssl_version=ssl.PROTOCOL_SSLv23)
def __init__(self, host='localhost', port=4966,
logRequests=False, allow_none=True,
keepalive_time=3*24*3600):
self.out_buffer = []
self.larch = Interpreter(writer=self)
self.larch.input.prompt = ''
self.larch.input.prompt2 = ''
self.larch.run_init_scripts()
self.larch('_sys.client = group(keepalive_time=%f)' % keepalive_time)
self.larch('_sys.wx = group(wxapp=None)')
_sys = self.larch.symtable._sys
_sys.color_exceptions = False
_sys.client.last_event = int(time())
_sys.client.pid_server = int(os.getpid())
_sys.client.app = 'unknown'
_sys.client.pid = 0
_sys.client.user = '******'
_sys.client.machine = socket.getfqdn()
self.client = self.larch.symtable._sys.client
self.port = port
SimpleXMLRPCServer.__init__(self, (host, port),
logRequests=logRequests,
allow_none=allow_none)
self.register_introspection_functions()
self.register_function(self.larch_exec, 'larch')
for method in ('ls', 'chdir', 'cd', 'cwd', 'shutdown',
'set_keepalive_time', 'set_client_info',
'get_client_info', 'get_data', 'get_rawdata',
'get_messages', 'len_messages'):
self.register_function(getattr(self, method), method)
# sys.stdout = self
self.finished = False
signal.signal(signal.SIGINT, self.signal_handler)
self.activity_thread = Thread(target=self.check_activity)
def __init__(self, addr, log_requests=1):
"""
Overrides SimpleXMLRPCServer to set option to allow_reuse_address.
"""
# allow_reuse_address defaults to False in Python 2.4. We set it
# to True to allow quick restart on the same port. This is equivalent
# to calling setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
self.allow_reuse_address = True
if rosgraph.network.use_ipv6():
logger = logging.getLogger('xmlrpc')
# The XMLRPC library does not support IPv6 out of the box
# We have to monipulate private members and duplicate
# code from the constructor.
# TODO IPV6: Get this into SimpleXMLRPCServer
SimpleXMLRPCServer.__init__(self,
addr,
SilenceableXMLRPCRequestHandler,
log_requests,
bind_and_activate=False)
self.address_family = socket.AF_INET6
self.socket = socket.socket(self.address_family, self.socket_type)
logger.info('binding ipv6 xmlrpc socket to' + str(addr))
# TODO: set IPV6_V6ONLY to 0:
# self.socket.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)
self.server_bind()
self.server_activate()
logger.info('bound to ' + str(self.socket.getsockname()[0:2]))
# TODO IPV6: check Windows compatibility
# [Bug #1222790] If possible, set close-on-exec flag; if a
# method spawns a subprocess, the subprocess shouldn't have
# the listening socket open.
if fcntl is not None and hasattr(fcntl, 'FD_CLOEXEC'):
flags = fcntl.fcntl(self.fileno(), fcntl.F_GETFD)
flags |= fcntl.FD_CLOEXEC
fcntl.fcntl(self.fileno(), fcntl.F_SETFD, flags)
else:
SimpleXMLRPCServer.__init__(self, addr,
SilenceableXMLRPCRequestHandler,
log_requests)
def __init__(self, host, port, username, password, *args, **kargs):
self.username = username
self.password = password
# authenticate method is called from inner class
class VerifyingRequestHandler(SimpleXMLRPCRequestHandler):
# method to override
def parse_request(request):
if SimpleXMLRPCRequestHandler.parse_request(request):
# authenticate
if self.authenticate(request.headers):
return True
else:
# if authentication fails return 401
request.send_error(401,
'Authentication failed, Try agin.')
return False
# initialize
SimpleXMLRPCServer.__init__(self, (host, port),
requestHandler=VerifyingRequestHandler,
*args,
**kargs)
def __init__( self, interface ):
self.quit = False
SimpleXMLRPCServer.__init__( self,
interface,
requestHandler=SimpleXMLRPCRequestHandler,
logRequests=False, allow_none=True, use_builtin_types=True)
def __init__(self,addr,useSSL=False,logRequests=False,
allow_none=False, encoding=None):
""":param addr: the (server address,port)-tuple)
:param logRequests: patched thru to the base class"""
certfile=config().get("Network","personalSSLCertificate")
keyfile=config().get("Network","privateSSLKey")
self.useSSL=useSSL
if self.useSSL and not path.exists(certfile):
warning("No certficate file",certfile,
"exists. Therefor no SSL-connection for the FoamServer possible\n",
"To generate a private key:\n",
(" openssl genrsa -out %s 2048" % keyfile),
"\nThen generate the cerificate that is valid for 3 years with \n",
(" openssl req -new -x509 -key %s -out %s -days 1095" % (keyfile,certfile)))
self.useSSL=False
self.authOK=True
if self.useSSL:
try:
import ssl
if PY3:
import socketserver
else:
import SocketServer as socketserver
import socket
except ImportError:
warning("Problem with the imports. Dropping SSL-support")
self.useSSL=False
if self.useSSL:
self.logRequests = logRequests
SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
class VerifyingRequestHandler(SimpleXMLRPCRequestHandler):
'''
Request Handler that verifies username and security token to
XML RPC server in HTTP URL sent by client.
'''
# this is the method we must override
def parse_request(self):
# first, call the original implementation which returns
# True if all OK so far
if SimpleXMLRPCRequestHandler.parse_request(self):
# next we authenticate
if self.authenticate(self.headers):
return True
else:
# if authentication fails, tell the client
self.send_error(401, 'Authentication failed')
return False
def authenticate(self, headers):
from base64 import b64decode
# Confirm that Authorization header is set to Basic
authHeader=headers.get('Authorization')
if authHeader is None:
return True
(basic, _, encoded) = authHeader.partition(' ')
assert basic == 'Basic', 'Only basic authentication supported'
# Encoded portion of the header is a string
# Need to convert to bytestring
encodedByteString = encoded.encode()
# Decode Base64 byte String to a decoded Byte String
decodedBytes = b64decode(encodedByteString)
# Convert from byte string to a regular String
decodedString = decodedBytes.decode()
# Get the username and password from the string
(username, _, password) = decodedString.partition(':')
# Check that username and password match internal global dictionary
self.server.authOK=auth.checkAuthentication(username,password)
return True
# Override the normal socket methods with an SSL socket
socketserver.BaseServer.__init__(self, addr, VerifyingRequestHandler)
try:
self.socket = ssl.wrap_socket(
socket.socket(self.address_family, self.socket_type),
server_side=True,
keyfile=keyfile,
certfile=certfile,
cert_reqs=ssl.CERT_NONE,
ssl_version=ssl.PROTOCOL_SSLv23,
)
self.server_bind()
self.server_activate()
except socket.error as e:
warning("Socket error",e)
raise e
else:
SimpleXMLRPCServer.__init__(self,addr,logRequests=logRequests)
def __init__(self, addr, request_handler=SilenceableXMLRPCRequestHandler, log_requests=1):
SimpleXMLRPCServer.__init__(self, addr, request_handler, log_requests)
def __init__(self,addr,logRequests=False):
"""@param addr: the (server address,port)-tuple)
@param logRequests: patched thru to the base class"""
SimpleXMLRPCServer.__init__(self,addr,logRequests=logRequests)
def __init__(self, *args, **kwargs):
SimpleXMLRPCServer.__init__(self, *args, **kwargs)
def __init__(self, addr, instance):
SimpleXMLRPCServer.__init__(self, addr,
requestHandler=RPCRequestHandler, logRequests=False)
self.instance = instance
