def main():
options = get_options()
client = Client(options.host, options.port)
# show
if options.show:
reply = Document(client.show())
display(reply)
return reply.code
# load
path = options.load
if path:
reply = Document(client.load(path))
display(reply)
return reply.code
path = options.reload
# reload
if path:
reply = Document(client.reload(path))
display(reply)
return reply.code
# unload
path = options.unload
if path:
reply = Document(client.unload(path))
display(reply)
return reply.code
def __call__(self, *args, **kwargs):
try:
result = self.call(*args, **kwargs)
except Exception, e:
reply = Document()
reply.code = 1
reply.result = utf8(e)
result = reply
def __call__(self, *args, **kwargs):
try:
result = self.call(*args, **kwargs)
except Exception, e:
reply = Document()
reply.code = 1
reply.result = utf8(e)
result = reply
def __call__(self, *args, **kwargs):
try:
result = self.call(*args, **kwargs)
except Exception as e:
reply = Document()
reply.code = 1
reply.result = str(e)
result = reply
return result
def __call__(self, *args, **kwargs):
try:
result = self.call(*args, **kwargs)
except Exception as e:
reply = Document()
reply.code = 1
reply.result = str(e)
result = reply
return result
def dispatch(self, call):
"""
Dispatch the call to the handler.
:param call: A *call* document.
:type call: Document
"""
reply = Document()
try:
method = getattr(self.handler, call.name)
result = method(*call.args, **call.kwargs)
reply.code = 0
reply.result = result
except Exception, e:
reply.code = 1
reply.result = utf8(e)
def accepted(self, client):
"""
Process the request on the accepted socket.
:param client: A client socket.
:type client: socket.socket
"""
try:
client.setsockopt(IPPROTO_TCP, TCP_NODELAY, 1)
client.setsockopt(SOL_SOCKET, SO_LINGER, struct.pack('ii', 1, 1))
message = client.recv(4096)
call = Document()
call.load(message)
reply = self.dispatch(call)
client.send(reply)
except Exception, e:
log.error(utf8(e))
def test_trash(self, _document):
_document.return_value = Document()
message = 123
document, original, signature = peal(message)
self.assertEqual(document, _document.return_value)
self.assertEqual(original, message)
self.assertEqual(signature, None)
def accepted(self, client):
"""
Process the request on the accepted socket.
:param client: A client socket.
:type client: socket.socket
"""
try:
client.setsockopt(IPPROTO_TCP, TCP_NODELAY, 1)
client.setsockopt(SOL_SOCKET, SO_LINGER, struct.pack('ii', 1, 1))
message = client.recv(4096)
call = Document()
call.load(message)
reply = self.dispatch(call)
client.send(reply)
except Exception, e:
log.error(utf8(e))
def test_validation_failed_document_passed(self):
details = 'just failed'
document = Document(sn=1)
f = ValidationFailed(details=details, document=document)
self.assertEqual(f.code, ValidationFailed.CODE)
self.assertEqual(f.document, document)
self.assertEqual(f.args[0], ' : '.join((ValidationFailed.DESCRIPTION, details)))
def dispatch(self, request):
"""
Dispatch (invoke) the specified RMI request.
:param request: An RMI request
:type request: gofer.Document
:return: The RMI returned.
"""
dispatcher = self.dispatcher
call = Document(request.request)
if not self.provides(call.classname):
for plugin in Plugin.all():
if plugin == self:
continue
if not plugin.provides(call.classname):
# not provided
continue
valid = set()
valid.add('*')
valid.add(plugin.name)
if not valid.intersection(self.forward):
# (forwarding) not approved
continue
valid = set()
valid.add('*')
valid.add(self.name)
if not valid.intersection(plugin.accept):
# (accept) not approved
continue
dispatcher = plugin.dispatcher
break
return dispatcher.dispatch(request)
def test_run(self, builtin, pending, task, select_plugin, tx, aborted):
builtin.return_value = Mock(name='builtin')
plugin = Mock(name='plugin')
task_list = [
Mock(name='task-1'),
Mock(name='task-2'),
]
tx_list = [
Mock(name='tx-1'),
Mock(name='tx-2'),
]
request_list = [
Document(sn=1),
Document(sn=2),
]
task.side_effect = task_list
tx.side_effect = tx_list
aborted.side_effect = [False, False, True]
pending.return_value.get.side_effect = request_list
builtin.return_value.provides.side_effect = [True, False]
select_plugin.side_effect = [builtin.return_value, plugin]
# test
scheduler = Scheduler(plugin)
scheduler.run()
# validation
builtin.return_value.pool.run.assert_called_once_with(task_list[0])
plugin.pool.run.assert_called_once_with(task_list[1])
self.assertEqual(
select_plugin.call_args_list,
[
((request_list[0],), {}),
((request_list[1],), {}),
])
self.assertEqual(
tx.call_args_list,
[
((builtin.return_value, pending.return_value, request_list[0]), {}),
((plugin, pending.return_value, request_list[1]), {})
])
self.assertEqual(
task.call_args_list,
[
((tx_list[0],), {}),
((tx_list[1],), {}),
])
def _read(path):
"""
Read a request.
:param path: The path to the journal file.
:type path: str
:return: The read request.
:rtype: Document
"""
with open(path) as fp:
try:
request = Document()
body = fp.read()
request.load(body)
log.debug('read [%s]: %s', path, body)
return request
except ValueError:
log.error('%s corrupt (discarded)', path)
unlink(path)
def call(self, *args, **kwargs):
"""
Remote call.
"""
socket = Socket(AF_INET, SOCK_STREAM)
socket.connect(self.address)
try:
method = Document()
method.name = self.name
method.args = args
method.kwargs = kwargs
socket.send(method.dump())
reply = socket.recv(4096)
result = Document()
result.load(reply)
return result
finally:
socket.close()
def _rejected(self, code, description, document, details):
"""
Called to process the received (invalid) document.
This method intended to be overridden by subclasses.
:param code: The rejection code.
:type code: str
:param description: rejection description
:type description: str
:param document: The received (json) document.
:type document: str
:param details: The explanation.
:type details: str
"""
details = dict(
code=code,
description=description,
details=details)
request = Document()
request.load(document)
self._send(request, 'rejected', **details)
def test_validate_failed(self, _document):
_document.return_value = Document()
message = '[]'
authenticator = Mock()
authenticator.validate.side_effect = ValidationFailed
# functional test
try:
validate(authenticator, message)
self.assertTrue(False, msg='validation exception expected')
except ValidationFailed as e:
self.assertEqual(e.document, _document.return_value)
def test_send_not_addressed(self, send):
node = Queue()
plugin = Mock(url='')
request = Document(replyto=None)
status = 'rejected'
consumer = RequestConsumer(node, plugin)
# Test
consumer.send(request, status)
# Validation
self.assertFalse(send.called)
def _read(path):
"""
Read a request.
:param path: The path to the journal file.
:type path: str
:return: The read request.
:rtype: Document
"""
fp = open(path)
try:
try:
request = Document()
body = fp.read()
request.load(body)
log.debug('read [%s]: %s', path, body)
return request
except ValueError:
log.error('%s corrupt (discarded)', path)
os.unlink(path)
finally:
fp.close()
def test_dispatch(self):
request = Document(routing=['A', 'B'],
request={
'classname': 'Admin',
'method': 'hello',
'args': [],
'keywords': {}
})
plugin = Mock()
builtin = Builtin(plugin)
result = builtin.dispatch(request)
self.assertEqual(result.retval, Admin().hello())
def test_run_raised(self, aborted, select_plugin, pending):
plugin = Mock()
sn = 1234
pending.return_value.get.return_value = Document(sn=sn)
select_plugin.side_effect = ValueError
aborted.side_effect = [False, True]
# test
scheduler = Scheduler(plugin)
scheduler.run()
# validation
pending.return_value.commit.assert_called_once_with(sn)
def test_dispatch(self):
node = Queue()
plugin = Mock(url='')
request = Document()
consumer = RequestConsumer(node, plugin)
consumer.send = Mock()
# Test
consumer.dispatch(request)
# Validation
consumer.send.assert_called_once_with(request, 'accepted')
plugin.scheduler.add.assert_called_once_with(request)
def select_plugin(self, request):
"""
Select the plugin based on the request.
:param request: A request to be scheduled.
:rtype request: gofer.messaging.Document
:return: The appropriate plugin.
:rtype: gofer.agent.plugin.Plugin
"""
call = Document(request.request)
if self.builtin.provides(call.classname):
plugin = self.builtin
else:
plugin = self.plugin
return plugin
def test_validate_exception(self, _document):
_document.return_value = Document()
message = '[]'
reason = 'this is bad'
authenticator = Mock()
authenticator.validate.side_effect = ValueError(reason)
# functional test
try:
validate(authenticator, message)
self.assertTrue(False, msg='validation exception expected')
except ValidationFailed as e:
self.assertEqual(e.details, reason)
self.assertEqual(e.document, _document.return_value)
def test_send(self, ts, _open, _close, send):
send.side_effect = ValueError
node = Queue()
plugin = Mock(url='')
request = Document(sn=1, replyto='elmer', data=123)
status = 'rejected'
details = dict(a=1)
consumer = RequestConsumer(node, plugin)
# Test
consumer.send(request, status, **details)
# Validation
_open.assert_called_once_with()
_close.assert_called_once_with()
def call(self, *args, **kwargs):
"""
Remote call.
"""
socket = Socket(AF_INET, SOCK_STREAM)
socket.connect(self.address)
try:
method = Document()
method.name = self.name
method.args = args
method.kwargs = kwargs
socket.send(method.dump())
reply = socket.recv(4096)
result = Document()
result.load(reply)
return result
finally:
socket.close()
def dispatch(self, call):
"""
Dispatch the call to the handler.
:param call: A *call* document.
:type call: Document
"""
reply = Document()
try:
method = getattr(self.handler, call.name)
result = method(*call.args, **call.kwargs)
reply.code = 0
reply.result = result
except Exception as e:
reply.code = 1
reply.result = str(e)
return reply.dump()
def test_select_plugin(self, builtin):
plugin = Mock()
request = Document(request={'classname': 'A'})
scheduler = Scheduler(plugin)
# find builtin
builtin.return_value.provides.return_value = True
selected = scheduler.select_plugin(request)
self.assertEqual(selected, builtin.return_value)
# find plugin
builtin.return_value.provides.return_value = False
selected = scheduler.select_plugin(request)
self.assertEqual(selected, plugin)
self.assertEqual(
builtin.return_value.provides.call_args_list,
[
(('A',), {}),
(('A',), {})
])
def test_rejected(self):
node = Queue()
plugin = Mock(url='')
code = '401'
description = 'failed'
details = dict(msg='failed')
document = Document(field='value')
consumer = RequestConsumer(node, plugin)
consumer.send = Mock()
# Test
consumer.rejected(code, description, document, details)
# Validation
consumer.send.assert_called_once_with(
document, 'rejected', **{
'code': code,
'description': description,
'details': details,
})
def test_send(self, ts, _open, _close, send):
node = Queue()
plugin = Mock(url='')
request = Document(sn=1, replyto='elmer', data=123)
status = 'rejected'
details = dict(a=1)
consumer = RequestConsumer(node, plugin)
# Test
consumer.send(request, status, **details)
# Validation
_open.assert_called_once_with()
send.assert_called_once_with(request.replyto,
sn=request.sn,
data=request.data,
status=status,
timestamp=ts.return_value,
**details)
_close.assert_called_once_with()
FinalReply,
Failed,
Succeeded,
Accepted,
Rejected,
Started,
Progress,
)
document = Document(sn='123',
routing=['A', 'B'],
timestamp='XX',
data={'msg': 'Hello' + chr(255)},
result={
'xmodule': ValueError.__module__,
'xclass': ValueError.__name__,
'xargs': 'Failed' + chr(255),
'xstate': {},
},
total=100,
completed=10,
details='Done' + chr(255))
class Listener(object):
def __init__(self):
self.accepted = Mock()
self.rejected = Mock()
self.started = Mock()
self.progress = Mock()
self.succeeded = Mock()
