def start(self, sockets=None, **kwargs): #pylint: disable=W0221
"""
Present the PTY of the container inside the current process.
This will take over the current process' TTY until the container's PTY
is closed.
"""
pty_stdin, pty_stdout, pty_stderr = sockets or self.sockets()
pumps = []
if pty_stdin and self.interactive:
#pylint: disable=C0301
pumps.append(
io.Pump(io.Stream(self.stdin),
pty_stdin,
wait_for_output=not sys.stdin.isatty()))
if pty_stdout:
pumps.append(
io.Pump(pty_stdout,
io.Stream(self.stdout),
propagate_close=False))
if pty_stderr:
pumps.append(
io.Pump(pty_stderr,
io.Stream(self.stderr),
propagate_close=False))
if not self.info()['State']['Running']:
self.client.start(self.container, **kwargs) #pylint: disable=W0613
return pumps
def start(self, sockets=None, **kwargs): #pylint: disable=W0221
"""
start execution
"""
stream = sockets or self.sockets()
pumps = []
if self.interactive:
pumps.append(
io.Pump(io.Stream(self.stdin), stream, wait_for_output=False))
pumps.append(
io.Pump(stream, io.Stream(self.stdout), propagate_close=False))
return pumps
def test_set_blocking_fd(self, fake_set_blocking):
"""``dockerpty.io`` Stream.set_blocking proxies the call to the file descriptor if possible"""
fake_fd = MagicMock()
io.Stream(fake_fd).set_blocking(56)
self.assertTrue(fake_fd.setblocking.called)
def test_needs_write(self):
"""``dockerpty.io`` Stream.needs_write Returns True when there's data in the buffer"""
fake_fd = MagicMock()
stream = io.Stream(fake_fd)
stream.buffer = b'some data'
self.assertTrue(stream.needs_write())
def test_set_blocking(self, fake_set_blocking):
"""``dockerpty.io`` Stream.set_blocking can manually set blocking on a the file descriptor"""
fake_fd = FakeFD()
io.Stream(fake_fd).set_blocking(56)
self.assertTrue(fake_set_blocking.called)
def test_do_write_os_write(self, fake_write):
"""``dockerpty.io`` Stream.do_write calls os.write when the file descriptor has no 'send' method"""
fake_fd = FakeFD()
fake_fd.fileno = lambda: 32
io.Stream(fake_fd).do_write()
self.assertTrue(fake_write.called)
def test_read_error(self):
"""``dockerpty.io`` Stream.read raises unexpected errors"""
fake_fd = MagicMock()
error = OSError()
error.errno = 8965
fake_fd.recv.side_effect = [error]
with self.assertRaises(OSError):
io.Stream(fake_fd).read()
def test_read(self):
"""``dockerpty.io`` Stream.read returns N number of bytes from the stream"""
fake_fd = MagicMock()
fake_fd.recv.return_value = 'some bytes'
output = io.Stream(fake_fd).read()
expected = 'some bytes'
self.assertEqual(output, expected)
def test_do_write_error(self):
"""``dockerpty.io`` Stream.do_write closes when requested after writing"""
fake_fd = MagicMock()
error = OSError()
error.errno = 2346
fake_fd.send.side_effect = [error]
with self.assertRaises(OSError):
io.Stream(fake_fd).do_write()
def test_fileno(self):
"""``dockerpty.io`` Stream.fileno proxies to the file descriptor"""
fake_fd = MagicMock()
fake_fd.fileno.return_value = 9
output = io.Stream(fake_fd).fileno()
expected = 9
self.assertEqual(output, expected)
def test_repr(self):
"""``dockerpty.io`` Stream has a handy __repr__"""
fake_fd = FakeFD()
stream = io.Stream(fake_fd)
the_repr = '{}'.format(stream)
expected = 'Stream(some file descriptor object)'
self.assertEqual(the_repr, expected)
def test_close(self):
"""``dockerpty.io`` Stream.close closes the file descriptor"""
fake_fd = MagicMock()
stream = io.Stream(fake_fd)
stream.close()
self.assertTrue(stream.closed)
self.assertTrue(fake_fd.close.called)
def test_read_os(self, fake_read):
"""``dockerpty.io`` Stream.read calls to os.read if the file descriptor has no 'recv' attribute"""
fake_fd = FakeFD()
fake_fd.fileno = lambda : 56
fake_read.return_value = 'yay, bytes!'
output = io.Stream(fake_fd).read()
expected = 'yay, bytes!'
self.assertEqual(output, expected)
def test_close_os(self, fake_close):
"""``dockerpty.io`` Stream.close closes the file descriptor even if the fd had no 'close' attribute"""
fake_fd = FakeFD()
fake_fd.fileno = lambda: 3445
stream = io.Stream(fake_fd)
stream.close()
self.assertTrue(stream.closed)
self.assertTrue(fake_close.called)
def test_do_write(self):
"""``dockerpty.io`` Stream.do_write returns how many bytes were written"""
fake_fd = MagicMock()
fake_fd.send.return_value = 93
stream = io.Stream(fake_fd)
written = stream.do_write()
expected = 93
self.assertEqual(written, expected)
def sockets(self):
"""
Return a single socket which is processing all I/O to exec
"""
socket = self.client.exec_start(self.exec_id,
socket=True,
tty=sys.stdin.isatty())
stream = io.Stream(socket)
if self.is_process_tty(): #pylint: disable=R1705
return stream
else:
return io.Demuxer(stream)
def test_write(self):
"""``dockerpty.io`` Stream.write adds to the buffer, then calls 'do_write'"""
data = b'yay bites!'
fake_fd = MagicMock()
fake_do_write = MagicMock()
stream = io.Stream(fake_fd)
stream.do_write = fake_do_write
stream.write(data)
self.assertEqual(stream.buffer, data)
self.assertTrue(fake_do_write.called)
def test_write_return(self):
"""``dockerpty.io`` Stream.write returns the number of bytes written"""
data = b'yay bites!'
fake_fd = MagicMock()
fake_do_write = MagicMock()
stream = io.Stream(fake_fd)
stream.do_write = fake_do_write
bytes_written = stream.write(data)
expected = len(data)
self.assertEqual(bytes_written, expected)
def test_write_ignore(self):
"""``dockerpty.io`` Stream.write adds to the buffer, then calls 'do_write'"""
data = b''
fake_fd = MagicMock()
fake_do_write = MagicMock()
stream = io.Stream(fake_fd)
stream.do_write = fake_do_write
bytes_written = stream.write(data)
expected = 0
self.assertEqual(bytes_written, expected)
def test_do_write_closes(self):
"""``dockerpty.io`` Stream.do_write closes when requested after writing"""
fake_fd = MagicMock()
fake_fd.send.return_value = 3
fake_close = MagicMock()
stream = io.Stream(fake_fd)
stream.close = fake_close
stream.close_requested = True
stream.do_write()
self.assertTrue(fake_close.called)
def attach_socket(key):
if info['Config']['Attach{0}'.format(key.capitalize())]:
socket = self.client.attach_socket(
self.container,
{
key: 1,
'stream': 1,
'logs': self.logs
},
)
stream = io.Stream(socket)
#pylint: disable=R1705
if info['Config']['Tty']:
return stream
else:
return io.Demuxer(stream)
else:
return None
def test_init(self):
"""``dockerpty.io`` the Stream object only requires a file descriptor"""
fake_fd = MagicMock()
stream = io.Stream(fake_fd)
self.assertTrue(isinstance(stream, io.Stream))
def test_needs_write_false(self):
"""``dockerpty.io`` Stream.needs_write Returns False when buffer is empty"""
fake_fd = MagicMock()
stream = io.Stream(fake_fd)
self.assertFalse(stream.needs_write())