def start(zope_layer_dotted_name):
print(WAIT("Starting Zope robot server"))
zsl = Zope2Server()
zsl.start_zope_server(zope_layer_dotted_name)
print(READY("Started Zope robot server"))
listener = SimpleXMLRPCServer((LISTENER_HOST, LISTENER_PORT),
logRequests=False)
listener.allow_none = True
listener.register_function(zsl.zodb_setup, 'zodb_setup')
listener.register_function(zsl.zodb_teardown, 'zodb_teardown')
print_urls(zsl.zope_layer, listener)
try:
listener.serve_forever()
finally:
print()
print(WAIT("Stopping Zope robot server"))
zsl.stop_zope_server()
print(READY("Zope robot server stopped"))
def start_xmlrpc_server(addr='localhost', port=8000):
server = SimpleXMLRPCServer((addr, port))
functions = [
getRootNodePath, getitem, getChildNodes, getMethods, getMethodDoc,
getRepr, callMethod
]
for function in functions:
server.register_function(function, function.__name__)
thread.start_new_thread(server.serve_forever, tuple())
return server
def setUp(self):
endpoint = zipkin.configure(
"My test xmlrpclib application",
{"zipkin.collector": "localhost", "zipkin.service_name": "my app"},
)
bind_zipkin(endpoint)
server = SimpleXMLRPCServer(("localhost", SERVERPORT), allow_none=True)
server.register_function(sleep)
self.server = mp.Process(target=server.serve_forever)
self.server.start()
DummyClient.reset()
def setUp(self):
endpoint = zipkin.configure('My test xmlrpclib application', {
'zipkin.collector': 'localhost',
'zipkin.service_name': 'my app'
})
bind_zipkin(endpoint)
server = SimpleXMLRPCServer(('localhost', SERVERPORT), allow_none=True)
server.register_function(sleep)
self.server = mp.Process(target=server.serve_forever)
self.server.start()
DummyClient.reset()
def create_server(self):
try:
unix_port = None
port = self.config.getint('main', 'rpc-port')
except ValueError:
port = None
unix_port = self.config.get('main', 'rpc-port')
self.logger.info("Using unix socket " + unix_port)
if unix_port is None and (port is None or port < 0):
return None
if unix_port:
self.server = UnixXmlRpcServer(unix_port)
else:
self.server = SimpleXMLRPCServer(("localhost", port),
requestHandler=RequestHandler,
logRequests=0)
self.server.register_introspection_functions()
self.server.register_instance(self.momFuncs)
def xmlrpc_run(self, port=23333, bind='127.0.0.1', logRequests=False):
'''Start xmlrpc interface'''
try:
from six.moves.xmlrpc_server import SimpleXMLRPCServer
except ImportError:
from SimpleXMLRPCServer import SimpleXMLRPCServer
server = SimpleXMLRPCServer((bind, port), allow_none=True, logRequests=logRequests)
server.register_introspection_functions()
server.register_multicall_functions()
server.register_function(self.quit, '_quit')
server.register_function(self.__len__, 'size')
def dump_counter(_time, _type):
return self._cnt[_time].to_dict(_type)
server.register_function(dump_counter, 'counter')
def new_task(task):
if self.task_verify(task):
self.newtask_queue.put(task)
return True
return False
server.register_function(new_task, 'newtask')
def update_project():
self._force_update_project = True
server.register_function(update_project, 'update_project')
def get_active_tasks(project=None, limit=100):
allowed_keys = set((
'taskid',
'project',
'status',
'url',
'lastcrawltime',
'updatetime',
'track',
))
track_allowed_keys = set((
'ok',
'time',
'follows',
'status_code',
))
iters = [iter(x['active_tasks']) for k, x in iteritems(self.projects)
if x and (k == project if project else True)]
tasks = [next(x, None) for x in iters]
result = []
while len(result) < limit and tasks and not all(x is None for x in tasks):
updatetime, task = t = max(tasks)
i = tasks.index(t)
tasks[i] = next(iters[i], None)
for key in list(task):
if key == 'track':
for k in list(task[key].get('fetch', [])):
if k not in track_allowed_keys:
del task[key]['fetch'][k]
for k in list(task[key].get('process', [])):
if k not in track_allowed_keys:
del task[key]['process'][k]
if key in allowed_keys:
continue
del task[key]
result.append(t)
# fix for "<type 'exceptions.TypeError'>:dictionary key must be string"
# have no idea why
return json.loads(json.dumps(result))
server.register_function(get_active_tasks, 'get_active_tasks')
server.timeout = 0.5
while not self._quit:
server.handle_request()
server.server_close()
def start_reload(zope_layer_dotted_name, reload_paths=('src',),
preload_layer_dotted_name='plone.app.testing.PLONE_FIXTURE',
extensions=None):
print(WAIT("Starting Zope robot server"))
zsl = Zope2Server()
zsl.start_zope_server(preload_layer_dotted_name)
forkloop = ForkLoop()
watcher = Watcher(reload_paths, forkloop)
if extensions:
watcher.allowed_extensions = extensions
elif HAS_DEBUG_MODE:
watcher.allowed_extensions.remove('pt')
watcher.start()
forkloop.start()
if forkloop.exit:
print(WAIT("Stopping Zope robot server"))
zsl.stop_zope_server()
print(READY("Zope robot server stopped"))
return
# XXX: For unknown reason call to socket.gethostbyaddr may cause malloc
# errors on OSX in forked child when called from medusa http_server, but
# proper sleep seem to fix it:
import time
import socket
import platform
if 'Darwin' in platform.uname():
gethostbyaddr = socket.gethostbyaddr
socket.gethostbyaddr = lambda x: time.sleep(0.5) or (ZSERVER_HOST,)
# Setting smaller asyncore poll timeout will speed up restart a bit
import plone.testing.z2
plone.testing.z2.ZServer.timeout = 0.5
zsl.amend_zope_server(zope_layer_dotted_name)
if HAS_DEBUG_MODE:
import App.config
config = App.config.getConfiguration()
config.debug_mode = HAS_DEBUG_MODE
App.config.setConfiguration(config)
if 'Darwin' in platform.uname():
socket.gethostbyaddr = gethostbyaddr
print(READY("Zope robot server started"))
try:
listener = SimpleXMLRPCServer((LISTENER_HOST, LISTENER_PORT),
logRequests=False)
except socket.error as e:
print(ERROR(str(e)))
print(WAIT("Pruning Zope robot server"))
zsl.prune_zope_server()
return
listener.timeout = 0.5
listener.allow_none = True
listener.register_function(zsl.zodb_setup, 'zodb_setup')
listener.register_function(zsl.zodb_teardown, 'zodb_teardown')
try:
while not forkloop.exit:
listener.handle_request()
except select.error: # Interrupted system call
pass
finally:
print(WAIT("Pruning Zope robot server"))
zsl.prune_zope_server()
