def test_xmlrpc_execute(self):
"Test XML-RPC encoding and decoding functions."
cmd = _xmlrpc._CommandExecuteAndEncode(NewRemoteCommand())
result1 = CommandResult(None)
result1.append_result(self.rset)
packet = cmd()
self.assertEqual(
packet,
[
_xmlrpc.FORMAT_VERSION,
str(FABRIC_UUID),
utils.TTL,
'', # No error
[ # One result set with one row
{
'info': {
'names': ['foo']
},
'rows': [
("executed", ),
]
}
]
])
result2 = _xmlrpc._decode(packet)
def _decode(packet):
"""Decode the data structure used with XML-RPC into a CommandResult.
Since the result sets are merged into a single list of
dictionaries, we separate them into result sets using the keys for
the dictionaries.
"""
_LOGGER.debug("Decode packet: %s", packet)
version, fabric_uuid, ttl, error, rsets = packet
if version != FORMAT_VERSION:
raise TypeError("XML-RPC packet format version was %d, expected %d",
version, FORMAT_VERSION)
result = CommandResult(error, uuid=fabric_uuid, ttl=ttl)
if len(rsets) > 0:
for rset in rsets:
# If the result set contain at least one row, use that to
# deduce the types for the columns. If not, assume it is
# all strings.
if len(rset['rows']) > 0:
types = [ type(val) for val in rset['rows'][0] ]
else:
types = [ str ] * len(rset['info']['names'])
# Create the result set and add the rows from the packet.
rs = ResultSet(names=rset['info']['names'], types=types)
for row in rset['rows']:
rs.append_row(row)
result.append_result(rs)
return result
def execute(self, proc_uuids=None):
"""Wait until a set of procedures uniquely identified by their uuids
finish their execution.
However, before starting waiting, the function checks if the procedures
exist. If one of the procedures is not found, the following exception
is raised :class:`~mysql.fabric.errors.ProcedureError`.
:param proc_uuids: Iterable with procedures' UUIDs.
"""
if proc_uuids is None:
raise _errors.ProcedureError("Please, specify which procedure(s) you will be waiting for.")
procedures = []
for proc_uuid in proc_uuids:
proc_uuid = _uuid.UUID(proc_uuid.strip())
procedure = _executor.Executor().get_procedure(proc_uuid)
if not procedure:
raise _errors.ProcedureError("Procedure (%s) was not found." % (proc_uuid,))
procedures.append(procedure)
command_results = CommandResult(error=None)
for procedure in procedures:
command_result = ProcedureCommand.wait_for_procedures([procedure], True)
if command_result.error is None:
for result in command_result.results:
command_results.append_result(result)
else:
result = ResultSet(names=["uuid", "error"], types=[str, str])
result.append_row([str(procedure.uuid), str(command_result.error)])
command_results.append_result(result)
return command_results
def _decode(packet):
"""Decode the data structure used with XML-RPC into a CommandResult.
Since the result sets are merged into a single list of
dictionaries, we separate them into result sets using the keys for
the dictionaries.
"""
_LOGGER.debug("Decode packet: %s", packet)
version, fabric_uuid, ttl, error, rsets = packet
if version != FORMAT_VERSION:
raise TypeError("XML-RPC packet format version was %d, expected %d",
version, FORMAT_VERSION)
result = CommandResult(error, uuid=fabric_uuid, ttl=ttl)
if len(rsets) > 0:
for rset in rsets:
# If the result set contain at least one row, use that to
# deduce the types for the columns. If not, assume it is
# all strings.
if len(rset['rows']) > 0:
types = [type(val) for val in rset['rows'][0]]
else:
types = [str] * len(rset['info']['names'])
# Create the result set and add the rows from the packet.
rs = ResultSet(names=rset['info']['names'], types=types)
for row in rset['rows']:
rs.append_row(row)
result.append_result(rs)
return result
def test_basic(self):
result = CommandResult(None)
self.assertEqual(result.error, None)
self.assertEqual(len(result.results), 0)
result.append_result(self.rset)
self.assertEqual(len(result.results), 1)
# Check that indexing works and return the result set added.
self.assertEqual(result.results[0], self.rset)
# Check that passing something that is not a result set will
# raise an error.
self.assertRaises(_errors.CommandResultError, result.append_result, [])
result = CommandResult("Not working")
self.assertEqual(result.error, "Not working")
self.assertRaises(_errors.CommandResultError, result.append_result,
self.rset)
def execute(self, proc_uuids=None):
"""Wait until a set of procedures uniquely identified by their uuids
finish their execution.
However, before starting waiting, the function checks if the procedures
exist. If one of the procedures is not found, the following exception
is raised :class:`~mysql.fabric.errors.ProcedureError`.
:param proc_uuids: Iterable with procedures' UUIDs.
"""
if proc_uuids is None:
raise _errors.ProcedureError(
"Please, specify which procedure(s) you will be waiting for.")
procedures = []
for proc_uuid in proc_uuids:
proc_uuid = _uuid.UUID(proc_uuid.strip())
procedure = _executor.Executor().get_procedure(proc_uuid)
if not procedure:
raise _errors.ProcedureError("Procedure (%s) was not found." %
(proc_uuid, ))
procedures.append(procedure)
command_results = CommandResult(error=None)
for procedure in procedures:
command_result = ProcedureCommand.wait_for_procedures([
procedure,
], True)
if command_result.error is None:
for result in command_result.results:
command_results.append_result(result)
else:
result = ResultSet(names=['uuid', 'error'], types=[str, str])
result.append_row(
[str(procedure.uuid),
str(command_result.error)])
command_results.append_result(result)
return command_results
