def serve(self):
self.socket.listen(0)
while True:
connection, address = self.socket.accept()
self.logger.info("Connected by {0}".format(address))
connection = ssl.wrap_socket(
connection,
keyfile=self.keyfile,
certfile=self.certfile,
server_side=True,
cert_reqs=self.cert_reqs,
ssl_version=self.ssl_version,
ca_certs=self.ca_certs,
do_handshake_on_connect=self.do_handshake_on_connect,
suppress_ragged_eofs=self.suppress_ragged_eofs)
factory = KMIPProtocolFactory()
protocol = factory.getProtocol(connection)
try:
while True:
self._processor.process(protocol, protocol)
except EOFError as e:
self.logger.warning("KMIPServer {0} {1}".format(type(e), e))
except Exception as e:
self.logger.error('KMIPServer {0} {1}'.format(type(e), e))
finally:
connection.close()
self.logger.info('Connection closed')
def _integration_test_process(self, request, expected):
"""
Semi-integration test of the Request processing;
includes the encode/decode of messages and operation specific
Payloads.
WF is mocked on the socket level:
- request blob data are supplied to socket in two chunks:
-- Request tag/type/length;
-- Request Message data.
- data sent by socket are restored from the mock-calls and compared
with expected data (excluding the TimeStamp data -- TODO).
"""
socket = mock.MagicMock()
socket.recv = mock.MagicMock(side_effect=[request[:8], request[8:]])
socket.sendall = mock.MagicMock()
factory = KMIPProtocolFactory()
protocol = factory.getProtocol(socket)
handler = KMIPImpl()
processor = Processor(handler)
processor.process(protocol, protocol)
(args, kwargs) = socket.sendall.call_args
to_cmp = self._setTimeStamp(args[0], expected)
self.assertEqual(expected, to_cmp, "Unexpected error")
def serve(self):
self.socket.listen(0)
while True:
connection, address = self.socket.accept()
self.logger.info("Connected by {0}".format(address))
connection = ssl.wrap_socket(
connection,
keyfile=self.keyfile,
certfile=self.certfile,
server_side=True,
cert_reqs=self.cert_reqs,
ssl_version=self.ssl_version,
ca_certs=self.ca_certs,
do_handshake_on_connect=self.do_handshake_on_connect,
suppress_ragged_eofs=self.suppress_ragged_eofs)
factory = KMIPProtocolFactory()
protocol = factory.getProtocol(connection)
try:
while True:
self._processor.process(protocol, protocol)
except EOFError as e:
self.logger.warning("KMIPServer {0} {1}".format(type(e), e))
except Exception as e:
self.logger.error('KMIPServer {0} {1}'.format(type(e), e))
finally:
connection.close()
self.logger.info('Connection closed')
def _integration_test_process(self, request, expected):
"""
Semi-integration test of the Request processing;
includes the encode/decode of messages and operation specific
Payloads.
WF is mocked on the socket level:
- request blob data are supplied to socket in two chunks:
-- Request tag/type/length;
-- Request Message data.
- data sent by socket are restored from the mock-calls and compared
with expected data (excluding the TimeStamp data -- TODO).
"""
socket = mock.MagicMock()
socket.recv = mock.MagicMock(side_effect=[request[:8], request[8:]])
socket.sendall = mock.MagicMock()
factory = KMIPProtocolFactory()
protocol = factory.getProtocol(socket)
handler = KMIPImpl()
processor = Processor(handler)
processor.process(protocol, protocol)
(args, kwargs) = socket.sendall.call_args
to_cmp = self._setTimeStamp(args[0], expected)
self.assertEqual(expected, to_cmp, "Unexpected error")
def setUp(self):
super(TestKMIPProtocol, self).setUp()
self.factory = KMIPProtocolFactory()
class TestKMIPProtocol(TestCase):
request = binascii.unhexlify(
'42007801000000b04200770100000088420069010000002042006a02000000040'
'00000010000000042006b0200000004000000010000000042000c010000004842'
'00230100000040420024050000000400000001000000004200250100000028420'
'099070000000a4b6d6970436c69656e740000000000004200a10700000006436f'
'75636f75000042000d0200000004000000010000000042000f010000001842005'
'c05000000040000001e000000004200790100000000')
response = binascii.unhexlify(
'42007b01000000d042007a0100000048420069010000002042006a02000000040'
'00000010000000042006b02000000040000000100000000420092090000000800'
'00000056bda8eb42000d0200000004000000010000000042000f0100000078420'
'05c05000000040000001e0000000042007f050000000400000000000000004200'
'7c0100000050420069010000002042006a0200000004000000010000000042006'
'b02000000040000000100000000420069010000002042006a0200000004000000'
'010000000042006b02000000040000000000000000')
def setUp(self):
super(TestKMIPProtocol, self).setUp()
self.factory = KMIPProtocolFactory()
def tearDown(self):
super(TestKMIPProtocol, self).tearDown()
def test_init(self):
"""
Test that a KmipProtocol can be created without errors.
"""
socket = MagicMock()
KMIPProtocol(socket)
def test_protocol_factory(self):
mock_name = 'test_protocol_factory'
socket = MagicMock(mock_name=mock_name)
protocol = self.factory.getProtocol(socket)
base = "expected {0}, received {1}"
msg = base.format(KMIPProtocol, protocol)
self.assertIsInstance(protocol, KMIPProtocol, msg)
self.assertEqual(protocol.socket.mock_name, mock_name, msg)
def test_IO_write(self):
socket = MagicMock()
protocol = self.factory.getProtocol(socket)
protocol.logger = MagicMock()
protocol.write(self.request)
protocol.logger.debug.assert_any_call(
"KMIPProtocol.write: {0}".format(binascii.hexlify(self.request)))
protocol.socket.sendall.assert_called_once_with(self.request)
def test_IO_read(self):
socket = MagicMock()
socket.recv = MagicMock(
side_effect=[self.response[:8], self.response[8:]])
protocol = self.factory.getProtocol(socket)
received = protocol.read()
socket.recv.assert_any_call(8)
socket.recv.assert_any_call(len(self.response) - 8)
self.assertEqual(self.response, received.peek())
def test_IO_read_EOF(self):
socket = MagicMock()
socket.recv = MagicMock(side_effect=[[]])
protocol = self.factory.getProtocol(socket)
try:
protocol.read()
except Exception as e:
self.assertIsInstance(e, EOFError, "Invalid exception")
else:
self.assertTrue(False, "Unexpected error")
socket.recv.assert_any_call(8)
def test_IO_read_request_length_mismatch(self):
socket = MagicMock()
socket.recv = MagicMock(
side_effect=[self.response[:8], self.response[8:16], []])
protocol = self.factory.getProtocol(socket)
resp_len = len(self.response)
try:
protocol.read()
except Exception as e:
self.assertIsInstance(
e, RequestLengthMismatch, "Invalid exception")
self.assertEqual(e.expected, resp_len - 8, "Unexpected expected")
self.assertEqual(e.received, 8, "Unexpected received")
self.assertEqual(
"{0}".format(e),
"{0}: expected {1}, received {2}".format(
"KMIPProtocol read error", resp_len - 8, 8),
"Invalid RequestLengthMismatch attributes")
else:
self.assertTrue(False, "Unexpected error")
calls = [call(8), call(resp_len - 8), call(resp_len - 16)]
socket.recv.assert_has_calls(calls)
def setUp(self):
super(TestKMIPProtocol, self).setUp()
self.factory = KMIPProtocolFactory()
class TestKMIPProtocol(TestCase):
request = binascii.unhexlify(
'42007801000000b04200770100000088420069010000002042006a02000000040'
'00000010000000042006b0200000004000000010000000042000c010000004842'
'00230100000040420024050000000400000001000000004200250100000028420'
'099070000000a4b6d6970436c69656e740000000000004200a10700000006436f'
'75636f75000042000d0200000004000000010000000042000f010000001842005'
'c05000000040000001e000000004200790100000000')
response = binascii.unhexlify(
'42007b01000000d042007a0100000048420069010000002042006a02000000040'
'00000010000000042006b02000000040000000100000000420092090000000800'
'00000056bda8eb42000d0200000004000000010000000042000f0100000078420'
'05c05000000040000001e0000000042007f050000000400000000000000004200'
'7c0100000050420069010000002042006a0200000004000000010000000042006'
'b02000000040000000100000000420069010000002042006a0200000004000000'
'010000000042006b02000000040000000000000000')
def setUp(self):
super(TestKMIPProtocol, self).setUp()
self.factory = KMIPProtocolFactory()
def tearDown(self):
super(TestKMIPProtocol, self).tearDown()
def test_init(self):
"""
Test that a KmipProtocol can be created without errors.
"""
socket = MagicMock()
KMIPProtocol(socket)
def test_protocol_factory(self):
mock_name = 'test_protocol_factory'
socket = MagicMock(mock_name=mock_name)
protocol = self.factory.getProtocol(socket)
base = "expected {0}, received {1}"
msg = base.format(KMIPProtocol, protocol)
self.assertIsInstance(protocol, KMIPProtocol, msg)
self.assertEqual(protocol.socket.mock_name, mock_name, msg)
def test_IO_write(self):
socket = MagicMock()
protocol = self.factory.getProtocol(socket)
protocol.logger = MagicMock()
protocol.write(self.request)
protocol.logger.debug.assert_any_call("KMIPProtocol.write: {0}".format(
binascii.hexlify(self.request)))
protocol.socket.sendall.assert_called_once_with(self.request)
def test_IO_read(self):
socket = MagicMock()
socket.recv = MagicMock(
side_effect=[self.response[:8], self.response[8:]])
protocol = self.factory.getProtocol(socket)
received = protocol.read()
socket.recv.assert_any_call(8)
socket.recv.assert_any_call(len(self.response) - 8)
self.assertEqual(self.response, received.peek())
def test_IO_read_EOF(self):
socket = MagicMock()
socket.recv = MagicMock(side_effect=[[]])
protocol = self.factory.getProtocol(socket)
try:
protocol.read()
except Exception as e:
self.assertIsInstance(e, EOFError, "Invalid exception")
else:
self.assertTrue(False, "Unexpected error")
socket.recv.assert_any_call(8)
def test_IO_read_request_length_mismatch(self):
socket = MagicMock()
socket.recv = MagicMock(
side_effect=[self.response[:8], self.response[8:16], []])
protocol = self.factory.getProtocol(socket)
resp_len = len(self.response)
try:
protocol.read()
except Exception as e:
self.assertIsInstance(e, RequestLengthMismatch,
"Invalid exception")
self.assertEqual(e.expected, resp_len - 8, "Unexpected expected")
self.assertEqual(e.received, 8, "Unexpected received")
self.assertEqual(
"{0}".format(e), "{0}: expected {1}, received {2}".format(
"KMIPProtocol read error", resp_len - 8, 8),
"Invalid RequestLengthMismatch attributes")
else:
self.assertTrue(False, "Unexpected error")
calls = [call(8), call(resp_len - 8), call(resp_len - 16)]
socket.recv.assert_has_calls(calls)
