if imie == str(osoba).split()[0]:
wyszukane_kontakty += self.wypisz_kontakt(osoba)
if wyszukane_kontakty != '':
return wyszukane_kontakty
else:
return 'Nie ma takiego kontaktu'
if imie == '' and nazwisko != '': # po nazwisku
wyszukane_kontakty = ''
for osoba in self.kontakty:
if nazwisko == str(osoba).split()[1]:
wyszukane_kontakty += self.wypisz_kontakt(osoba)
if wyszukane_kontakty != '':
return wyszukane_kontakty
else:
return 'Nie ma takiego kontaktu'
return ''
if __name__ == "__main__":
server = SimpleXMLRPCServer(("localhost", 8888))
kontakty_serwer = KontaktySerwer()
server.register_function(kontakty_serwer.wypisz_liste)
server.register_function(kontakty_serwer.dodaj_kontakt)
server.register_function(kontakty_serwer.usun_kontakt)
server.register_function(kontakty_serwer.wyszukaj_kontakt)
server.serve_forever()
from xmlrpc.server import SimpleXMLRPCServer
def sub(n1, n2):
return n1 - n2
server = SimpleXMLRPCServer(("localhost", 8002))
print("Listening on port 8002...")
server.register_function(sub, "sub")
server.serve_forever()
if len(sys.argv) != 2: # sys.argv[0] exe file itself
port = 5011
else:
port = int(sys.argv[1])
if my_config.debug_mode:
'''
import time
img_file_source = '/tmp1/00ed40ec-681c-42c3-afca-ca906ff11ecb.1.jpg'
for i in range(3):
# about one second in 171 server
print('start:', time.time())
confidence, img_file_mask_tmp, img_file_crop_optic_disc, img_file_draw_circle = \
detect_optic_disc_mask(img_file_source, True)
print('end:', time.time())
'''
img_file_source = '/media/ubuntu/data2/posterior_2020_4_27/add_posterior/original/0aac4dc7cd8eccc36b4396ad8ff65bfd1604f675#0f6c2bdb-0490-4714-879b-4ab1a33db917.13.jpg'
img_file_blood_vessel_seg = '/media/ubuntu/data2/posterior_2020_4_27/add_posterior/blood_vessel_seg_result1/0aac4dc7cd8eccc36b4396ad8ff65bfd1604f675#0f6c2bdb-0490-4714-879b-4ab1a33db917.13.jpg'
confidence, img_file_mask_tmp, img_file_crop_optic_disc, img_file_draw_circle, img_file_blood_vessel_seg_posterior = \
detect_optic_disc(img_file_source, True, img_file_blood_vessel_seg)
server = SimpleXMLRPCServer(("localhost", port))
print("Listening on port: ", str(port))
server.register_function(detect_optic_disc, "detect_optic_disc")
server.serve_forever()
print('OK')
from xmlrpc.server import SimpleXMLRPCServer
import xmlrpc.client
def file_upload(filedata): # initialize 'file_upload' function in server
with open("uploaded_file_ftp.txt",'wb') as handle:
data1=filedata.data #convert from byte to binary IMPORTANT!
handle.write(data1)
handle.close()
return True #IMPORTANT
# must have return value
# else error messsage: "cannot marshal None unless allow_none is enabled"
def file_download(): # create a function 'file_download'
handle = open("ZeroMQ-4.0.4_miru1.0-x64.exe",'rb') # initialize the handle with ZeroMQ, read binary
return xmlrpc.client.Binary(handle.read()) # give the output in binary form that can be read by client
handle.close()
server = SimpleXMLRPCServer(('192.168.1.8',8000)) # initialize the network and port
print ("Listening on port 8000") # the output when the server is running
server.register_function(file_upload,'file_upload') # registered the file_download function with new initialize 'download'
server.register_function(file_download,'download') # registered the file_download function with new initialize 'download'
server.serve_forever() # server will run forever, until we interrupt it
simple_server.register_function(getattr(self, func_name),
func_name)
@add_handle
def get_string(self, str_just_test):
return "get is :%s" % str_just_test
def pack_response(self, *args, **kwargs):
ret_obj = {'isok': True}
ret_obj.update(kwargs)
return json.dumps(ret_obj)
def unpack_request(self, req_str):
return json.loads(req_str)
@add_handle
def cmd(self, request):
req = self.unpack_request(request)
cmd_str = req['cmd_str']
cmd_list = cmd_str.split(' ', 1)
command = cmd_list[0]
args = cmd_list[1] if len(cmd_list) > 1 else ''
resp_str = self._cmd(command, args)
return self.pack_response(result=resp_str)
if __name__ == '__main__':
s = SimpleXMLRPCServer(('0.0.0.0', 8080))
_is = IstaServer(s)
s.serve_forever()
from xmlrpc.server import SimpleXMLRPCServer
from xmlrpc.server import SimpleXMLRPCRequestHandler
# Restrict to a particular path.
class RequestHandler(SimpleXMLRPCRequestHandler):
rpc_paths = ('/RPC2', )
# Create server
with SimpleXMLRPCServer(('localhost', 8000),
requestHandler=RequestHandler) as server:
server.register_introspection_functions()
# Register pow() function; this will use the value of
# pow.__name__ as the name, which is just 'pow'.
server.register_function(pow)
# Register a function under a different name
def adder_function(x, y):
return x + y
server.register_function(adder_function, 'add')
# Register an instance; all the methods of the instance are
# published as XML-RPC methods (in this case, just 'mul').
class MyFuncs:
def mul(self, x, y):
return x * y
server.register_instance(MyFuncs())
def file_upload(filedata):
# buka file
with open("hasil_upload.txt", 'wb') as handle:
# convert from byte to binary IMPORTANT!
data1 = filedata.data
# tulis file tersebut
handle.write(data1)
return True # IMPORTANT
# must have return value
# else error messsage: "cannot marshal None unless allow_none is enabled"
# buat server
server = SimpleXMLRPCServer(('127.0.0.1', 5003))
# buat server serta register fungsi register_introspection_functions()
# with SimpleXMLRPCServer(("127.0.0.1", 5003), requestHandler=RequestHandler) as server:
# server.register_introspection_functions()
# tulis pesan server telah berjalan
print("Listening on port 5003")
# register fungsi
server.register_function(file_upload, 'file')
# jalankan server
server.serve_forever()
# simple xmlrpc server. serving content of a directory
from xmlrpc.server import SimpleXMLRPCServer
import logging
import os
logging.basicConfig(level=logging.INFO)
server = SimpleXMLRPCServer(
('localhost', 5678),
logRequests=True,
)
def listdir(dir_name): # dir_name absolute/relative path
logging.info("list content of dir: {}".format(dir_name))
try:
return os.listdir(dir_name)
except OSError:
return "no such file or directory!"
# the client must access via "dir()" instead of "listdir()"
# server.register_function(listdir, 'dir')
# namespace is allowed
server.register_function(listdir, 'dir.list')
try:
server.serve_forever()
except KeyboardInterrupt:
print("exit...")
from xmlrpc.server import SimpleXMLRPCServer
import datetime, socket, random, array
#xmlrpclib,
# Create server
server = SimpleXMLRPCServer(("localhost", 8888), allow_none=True)
# Register an instance; all the methods of the instance are
# published as XML-RPC methods
class MyFuncs:
def add(self, x, y):
return x + y
def addOneDay(self, now):
now = datetime.datetime.strptime(str(now), "%Y%m%dT%H:%M:%S")
return now + datetime.timedelta(1)
def getHostName(self, android):
host = socket.gethostname()
return "android: " + android + "\nhost: " + host
def testStruct(self, inMap):
city = inMap["City"]
map = {"City": city, "Temperature": 24}
return map
def testArray(self, inArray):
sum = 0
for i in inArray:
# -*- coding: utf-8 -*-
from xmlrpc.server import SimpleXMLRPCServer
from xmlrpc.server import SimpleXMLRPCRequestHandler
import sqlite3
import datetime
connection = sqlite3.connect('microblog2.db') # Conexao do banco de dados
cursor = connection.cursor() # Cursor para executar queries
# Permite varios usuarios
class RequestHandler(SimpleXMLRPCRequestHandler):
rpc_paths = ('/RPC2',)
# Cria o Elemento Servidor
server = SimpleXMLRPCServer(("localhost", 8592),
requestHandler=RequestHandler)
server.register_introspection_functions()
# Id para os posts
idpost = 0
# Cria tabela Topico
try:
cursor.execute("CREATE TABLE topico (username varchar(50) PRIMARY KEY, sod int, cc int, cd int)")
except:
cursor.execute("DROP TABLE topico") # dropa a tabela caso ela ja exista
cursor.execute("CREATE TABLE topico (username varchar(50) PRIMARY KEY, sod int, cc int, cd int)")
# Cria tabela Post
try:
cursor.execute("CREATE TABLE post (username varchar(50) PRIMARY KEY, sod int, cc int, cd int)")
from xmlrpc.server import SimpleXMLRPCServer
class funciones_remota:
def suma(self, x, y):
return x + y
def resta(self, x, y):
return x - y
def multi(self, x, y):
return x * y
def div(self, x, y):
return x / y
def pot(self, x, y):
return x**y
server = SimpleXMLRPCServer(("192.168.8.180", 8001))
server.register_instance(funciones_remota(), "funciones")
print("Hola amigos, soy el servidor y estoy corriendo por el puerto 8001")
server.serve_forever()
#!/usr/bin/env python3
# encoding: utf-8
#
# Copyright (c) 2008 Doug Hellmann All rights reserved.
#
"""
"""
#end_pymotw_header
from xmlrpc.server import SimpleXMLRPCServer
import os
server = SimpleXMLRPCServer(('localhost', 9000))
def list_contents(dir_name):
"Expose a function with an alternate name"
return os.listdir(dir_name)
server.register_function(list_contents, 'dir')
try:
print('Use Control-C to exit')
server.serve_forever()
except KeyboardInterrupt:
print('Exiting')
from xmlrpc.server import SimpleXMLRPCServer
import xmlrpc.client
import paho.mqtt.client as mqtt
ip = "127.0.0.1"
mqttPort = 1883
rpcPort = 8889
topikPub = "/status/1"
opStatus = ""
server = SimpleXMLRPCServer((ip, rpcPort), allow_none=True)
clientMqtt = mqtt.Client(client_id="pub1", clean_session=False)
def status(pulsa):
if pulsa == "sukses":
opStatus = "Transaksi berhasil"
else:
opStatus = "Transaksi gagal"
print("Connect to ", ip)
clientMqtt.connect(ip, port=mqttPort)
print("Publish to ", topikPub)
clientMqtt.loop_start()
clientMqtt.publish(topikPub, payload=opStatus, qos=2)
clientMqtt.loop_stop()
server.register_function(status, "status")
server.serve_forever()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from xmlrpc.server import SimpleXMLRPCServer
import torchani
import torch
print("Starting TorchANI XML-RPC server ...")
address = ('localhost', 50000)
server = SimpleXMLRPCServer(address)
class TorchANI(object):
"""Provide the TorchANI calculation functions"""
def __init__(self):
if torch.cuda.is_available():
self.device = torch.device("cuda")
else:
self.device = torch.device("cpu")
self.model = torchani.models.ANI2x(periodic_table_index=True).to(
self.device)
def calc(self, s, c, update_forces=False, model_index=3):
coordinates = torch.tensor([c], requires_grad=True,
device=self.device).float()
species = torch.tensor([s], device=self.device)
m1 = self.model.species_converter((species, coordinates))
m2 = self.model.aev_computer(m1)
m3 = self.model.neural_networks[model_index](m2)[1]
if update_forces:
#endregion
# region test code
if my_config.debug_mode:
img_source = '/tmp1/img4.jpg'
if os.path.exists(img_source):
filename_CAM1 = server_cam(0,
img_source,
pred=1,
cam_relu=True,
preprocess=True,
blend_original_image=True)
# filename_CAM1 = server_cam(1, img_source, pred=1)
# filename_CAM1 = server_grad_cam(0, img_source, pred=1)
# filename_CAM1 = server_gradcam_plusplus(0, img_source, pred=1)
print(filename_CAM1)
#endregion
#region start service
# server = SimpleXMLRPCServer(("localhost", port))
server = SimpleXMLRPCServer(("0.0.0.0", port))
print("Listening on port: ", str(port))
server.register_function(server_cam, "server_cam")
server.register_function(server_gradcam_plusplus, "server_gradcam_plusplus")
server.serve_forever()
#endregion
def __init__(self, ip="localhost", puerto=5500, tipo="main"):
#Server Control
self.server = SimpleXMLRPCServer((ip, puerto),
requestHandler=RequestHandler,
allow_none=True)
self.server.register_introspection_functions()
self.ip = ip
self.puerto = puerto
self.tipo = tipo
self.servers = {}
self.filesPermission = {}
self.filesBusy = {}
self.filesList = []
#Tkinter
self.root = tkinter.Tk()
self.root.wm_title("archivos - " + tipo)
scrollbar = tkinter.Scrollbar(self.root, orient=tkinter.VERTICAL)
self.TextoBox = tkinter.Text(self.root,
height=8,
width=80,
yscrollcommand=scrollbar.set)
self.TextoBox2 = tkinter.Text(self.root,
height=8,
width=80,
yscrollcommand=scrollbar.set)
scrollbar.config(command=self.yview)
scrollbar.pack(side=tkinter.RIGHT, fill=tkinter.Y)
self.TextoBox.pack(side=tkinter.LEFT, fill=tkinter.Y)
self.TextoBox.config(state=tkinter.DISABLED)
self.TextoBox2.pack(side=tkinter.LEFT, fill=tkinter.Y)
self.TextoBox2.config(state=tkinter.DISABLED)
frame = tkinter.Frame(self.root)
frame.pack()
self.list = tkinter.Listbox(self.root,
selectmode=tkinter.SINGLE,
yscrollcommand=scrollbar.set)
self.list.pack(fill=tkinter.BOTH, expand=1)
self.buttonShowFile = tkinter.Button(frame,
text='Show File',
command=self.showInfo)
self.buttonShowFile.grid(row=2, columnspan=1)
self.buttonShowBusy = tkinter.Button(frame,
text='Select Busy Files',
command=self.showBusy)
self.buttonShowBusy.grid(row=3, columnspan=1)
self.buttonUpdate = tkinter.Button(frame,
text='Update Files',
command=self.updateFilesAll)
self.buttonUpdate.grid(row=4, columnspan=1)
self.buttonCancel = tkinter.Button(frame,
text='Cancel',
command=self.cancelAction)
self.buttonCancel.grid(row=5, columnspan=1)
self.buttonShowBusy.config(state=tkinter.DISABLED)
tkinter.Label(frame, text='Estado').grid(row=1, column=0)
self.answer = tkinter.StringVar()
self.answer.set("Ready")
tkinter.Label(frame, textvariable=self.answer).grid(row=1, column=1)
self.keyframes=keyframes
self.start_time=0
times=keyframes[1]
t=0
for i in range(len(times)):
tmp=max(times[i])
if(tmp>t):
t=tmp
time.sleep(t+1)
def get_transform(self, name):
'''get transform with given name'''
return self.transforms[name].tolist()
def set_transform(self, effector_name, transform):
'''solve the inverse kinematics and control joints use the results
'''
self.set_transforms(effector_name, np.asmatrix(transform))
if __name__ == '__main__':
agent = ServerAgent()
server = SimpleXMLRPCServer(('127.0.0.1', 9000), logRequests=True, allow_none=True)
server.register_function(pow)
server.register_instance(agent)
server_thread = threading.Thread(target=server.serve_forever)
server_thread.start()
agent.run()
def _start(self):
""" 供内部用来启动XML-RPC服务器 """
s = SimpleXMLRPCServer(("", get_port(self.url)), logRequests=False)
s.register_instance(self)
s.serve_forever()
def __init__(self, address):
self._data = {}
self._serv = SimpleXMLRPCServer(address, allow_none=True)
for name in self._rpc_methods_:
self._serv.register_function(getattr(self, name))
from xmlrpc.server import SimpleXMLRPCServer
def add(x, y):
return x + y
serv = SimpleXMLRPCServer(('', 15000))
serv.register_function(add)
serv.serve_forever()
# gunakan xmlrpc bagian server
# import SimpleXMLRPCServer dan SimpleXMLRPCRequestHandler
from xmlrpc.server import SimpleXMLRPCServer
from xmlrpc.server import SimpleXMLRPCRequestHandler
# buat kelas requesthandler
from com.frogobox.config import *
class RequestHandler(SimpleXMLRPCRequestHandler):
# batasi pada path /RPC2 saja
rpc_paths = (BASE_CONFIG_PATH)
# buat server serta register fungsi register_introspection_functions()
rpcServer = SimpleXMLRPCServer((BASE_CONFIG_IP_ADDRESS, BASE_CONFIG_PORT), requestHandler=RequestHandler)
rpcServer.register_introspection_functions()
# Buatlah fungsi kalkulasi dasar (tambah, kurang, kali, bagi, pangkat),
# anda dapat memilih ataupun menggunakan ketiga cara berikut:
# cara 1 untuk memasukkan fungsi dalam rpcServer adalah dengan langsung memasukkan namanya
# fungsi pow() merupakan fungsi build in pada pyhton, tinggal dipanggil saja
# cara 2 untuk register fungsi: buat fungsinya kemudian register
# a. buat fungsi
def plusMath(number1, number2):
return number1 + number2
def minusMath(number1, number2):
def init_reducer(address, port, reducer_num):
print("Reducer {} ready!".format(reducer_num))
server = SimpleXMLRPCServer((address, port), allow_none=True)
server.register_function(get_map_wordcount, "get_map_wordcount")
server.register_function(get_map_inverted_index, "get_map_inverted_index")
server.serve_forever()
from xmlrpc.server import SimpleXMLRPCServer
from xmlrpc.server import SimpleXMLRPCRequestHandler
class RequestHandler(SimpleXMLRPCRequestHandler):
rpc_paths = ('/RPC2', )
with SimpleXMLRPCServer(('0.0.0.0', 12345),
requestHandler=RequestHandler) as server:
server.register_introspection_functions()
server.register_function(pow)
@server.register_function(name='somma')
def adder_function(x, y):
return x + y
@server.register_function
def multiply(x, y):
return x * y
print('Server UP, in ascolto sul porto 12345 ...')
server.serve_forever()
#!/usr/local/bin/python
import time
import subprocess
from xmlrpc.server import SimpleXMLRPCServer
def is_even(n):
return n % 2 == 0
def spike_cpu(duration_seconds):
subprocess.run(["dd", "if=/dev/zero", "of=/dev/null"])
time.sleep(duration_seconds)
return duration_seconds
server = SimpleXMLRPCServer(("0.0.0.0", 80))
print("Listening on port 80...")
server.register_function(is_even, "is_even")
server.register_function(spike_cpu, "spike_cpu")
print("Press CTRL+C to end ..")
server.serve_forever()
def getMasterIpAddress():
return socket.gethostbyname(socket.gethostname())
def registerIP(ip_address):
with open("botnet_list.txt", "a") as file:
file.write(ip_address + "\n")
def unregisterIP(ip_address):
ip_list = []
with open("botnet_list.txt", "r") as file:
ip_list = file.readlines()
ip_list = [x.strip() for x in ip_list]
ip_list.remove(ip_address)
with open("botnet_list.txt", "w") as file:
for ip in ip_list:
file.write(ip + "\n")
if __name__ == '__main__':
server = SimpleXMLRPCServer((getMasterIpAddress(), 8000),
requestHandler=RequestHandler,
allow_none=True)
server.register_introspection_functions()
server.register_function(registerIP, "register_ip")
server.register_function(unregisterIP, "unregister_ip")
server.serve_forever()
level=logging.DEBUG)
console = logging.StreamHandler()
console.setLevel(logging.INFO)
logging.getLogger('').addHandler(console)
hostname = socket.gethostname()
IpAddress = socket.gethostbyname(hostname)
# Restrict to a particular path.
class RequestHandler(SimpleXMLRPCRequestHandler):
rpc_paths = ('/RPC2', )
# Create server
with SimpleXMLRPCServer((IpAddress, 8000),
requestHandler=RequestHandler) as server:
server.register_introspection_functions()
class Server:
def __init__(self):
self.userId = ''
self.userPass = ''
self.mysqlHost = 'localhost'
self.mysqlUser = '******'
self.mysqlPass = '******'
pass
def do_register(self, userid, userpass):
ret = ''
self.userId = userid
self.userPass = userpass
if __name__ == '__main__':
from threading import Thread
import socket
socket.setdefaulttimeout(10)
try:
from xmlrpc.server import SimpleXMLRPCServer
except ImportError:
from SimpleXMLRPCServer import SimpleXMLRPCServer
IP = '127.0.0.1'
PORT = int(sys.argv[1])
server = SimpleXMLRPCServer((IP, PORT), allow_none=True)
server.register_function(get_modules_search_paths, 'getModulesSearchPaths')
server.register_function(get_module_path, 'getModulePath')
server.register_function(get_classes_from_module, 'getClassesFromModule')
server.register_function(get_variables, 'getVariables')
server.register_function(get_global_variables, 'getGlobalVariables')
server.register_function(get_standard_libraries_names,
'getStandardLibrariesNames')
server.register_function(get_standard_library_path,
'getStandardLibraryPath')
server.register_function(get_site_packages_libraries_names,
'getSitePackagesLibrariesNames')
server.register_function(get_robot_version, 'getRobotVersion')
server.register_function(start_library_auto_discovering,
'startLibraryAutoDiscovering')
server.register_function(start_keyword_auto_discovering,
import sys
from instrucciones import *
from xmlrpc.server import SimpleXMLRPCServer
from xmlrpc.server import SimpleXMLRPCRequestHandler
HOST=sys.argv[1]; PORT=int(sys.argv[2])
class RequestHandler(SimpleXMLRPCRequestHandler): # Escucha a todos los solicitantes http
rpc_paths = ('/RPC2',) # Ruta principal
# Crea el servidor RPC
with SimpleXMLRPCServer((HOST,PORT),requestHandler=RequestHandler) as server:
print("Servidor a la escucha")
server.register_introspection_functions()
server.register_instance(Instrucciones()) # La clase se registra con todos sus metodos de forma xml
server.serve_forever()
def __init__(self, host="localhost", port=8000):
threading.Thread.__init__(self)
self.host = host
self.port = port
self.localServer = SimpleXMLRPCServer((self.host, self.port), allow_none=True)
def __init__(self,
local=LOCAL,
localport=LOCALPORT,
remotes=REMOTES,
devicefile=DEVICEFILE,
interface_id=INTERFACE_ID,
eventcallback=False,
systemcallback=False,
resolveparamsets=False):
LOG.debug("ServerThread.__init__")
threading.Thread.__init__(self)
# Member
self._interface_id = interface_id
self._local = local
self._localport = int(localport)
self._devicefile = devicefile
self.remotes = remotes
self.eventcallback = eventcallback
self.systemcallback = systemcallback
self.resolveparamsets = resolveparamsets
self.proxies = {}
# Create proxies to interact with CCU / Homegear
LOG.debug("__init__: Creating proxies")
for remote, host in self.remotes.items():
# Initialize XML-RPC
try:
socket.inet_pton(socket.AF_INET, host['ip'])
except Exception as err:
LOG.warning("Skipping proxy: %s" % str(err))
continue
if 'path' not in host:
host['path'] = ""
LOG.info("Creating proxy %s. Connecting to http://%s:%i%s" %
(remote, host['ip'], host['port'], host['path']))
host['id'] = "%s-%s" % (self._interface_id, remote)
try:
self.proxies[host['id']] = LockingServerProxy(
"http://%s:%i%s" %
(host['ip'], host['port'], host['path']),
callbackip=host.get('callbackip', None),
callbackport=host.get('callbackport', None),
skipinit=not host.get('connect', True))
except Exception as err:
LOG.warning("Failed connecting to proxy at http://%s:%i%s" %
(host['ip'], host['port'], host['path']))
LOG.debug("__init__: Exception: %s" % str(err))
raise Exception
try:
host['type'] = BACKEND_UNKNOWN
#if "Homegear" in self.proxies[host['id']].getVersion():
# LOG.debug("__init__: Host is Homegear")
# host['type'] = BACKEND_HOMEGEAR
#else:
# LOG.debug("__init__: Host is CCU")
# host['type'] = BACKEND_CCU
except Exception as err:
LOG.warning("__init__: Failed to detect backend type: %s" %
str(err))
host['type'] = BACKEND_UNKNOWN
if not self.proxies:
LOG.warning("No proxies available. Aborting.")
raise Exception
self._rpcfunctions = RPCFunctions(
devicefile=self._devicefile,
proxies=self.proxies,
remotes=self.remotes,
eventcallback=self.eventcallback,
systemcallback=self.systemcallback,
resolveparamsets=self.resolveparamsets)
# Setup server to handle requests from CCU / Homegear
LOG.debug("ServerThread.__init__: Setting up server")
self.server = SimpleXMLRPCServer((self._local, self._localport),
requestHandler=RequestHandler,
logRequests=False)
self._localport = self.server.socket.getsockname()[1]
self.server.register_introspection_functions()
self.server.register_multicall_functions()
LOG.debug("ServerThread.__init__: Registering RPC functions")
self.server.register_instance(self._rpcfunctions,
allow_dotted_names=True)
