def test_early_stream_response(self):
self.request_handler = self.early_response_sending_handler
lines = []
for i in range(0, 50):
line = str(i).encode()
lines += [('%x' % len(line)).encode(), line]
lines.append(b'0')
lines.append(b'')
self.response = (
b'HTTP/1.1 200 OK\r\n'
b'Transfer-Encoding: chunked\r\n'
b'\r\n'
) + b'\r\n'.join(lines)
with APIClient(base_url="http+unix://" + self.socket_file) as client:
for i in range(5):
try:
stream = client.build(
path=self.build_context,
)
break
except requests.ConnectionError as e:
if i == 4:
raise e
assert list(stream) == [
str(i).encode() for i in range(50)
]
def test_ctor(self):
with pytest.raises(docker.errors.DockerException) as excinfo:
APIClient(version=1.12)
assert str(
excinfo.value
) == 'Version parameter must be a string or None. Found float'
def test_read_from_socket(self):
with APIClient(base_url=self.address) as client:
resp = client._post(client._url('/dummy'), stream=True)
data = client._read_from_socket(resp, stream=True, tty=True)
results = b''.join(data)
assert results == self.text_data
def test_custom_user_agent(self):
client = APIClient(user_agent='foo/bar')
client.version()
assert self.mock_send.call_count == 1
headers = self.mock_send.call_args[0][0].headers
assert headers['User-Agent'] == 'foo/bar'
def test_custom_user_agent(self):
client = APIClient(user_agent='foo/bar')
client.version()
self.assertEqual(self.mock_send.call_count, 1)
headers = self.mock_send.call_args[0][0].headers
self.assertEqual(headers['User-Agent'], 'foo/bar')
def test_default_user_agent(self):
client = APIClient()
client.version()
self.assertEqual(self.mock_send.call_count, 1)
headers = self.mock_send.call_args[0][0].headers
expected = 'docker-sdk-python/%s' % docker.__version__
self.assertEqual(headers['User-Agent'], expected)
def test_default_user_agent(self):
client = APIClient()
client.version()
assert self.mock_send.call_count == 1
headers = self.mock_send.call_args[0][0].headers
expected = 'docker-sdk-python/%s' % docker.__version__
assert headers['User-Agent'] == expected
def setUp(self):
self.patcher = mock.patch.multiple(
'docker.api.client.APIClient',
get=fake_get,
post=fake_post,
put=fake_put,
delete=fake_delete,
_read_from_socket=fake_read_from_socket)
self.patcher.start()
self.client = APIClient()
def setUp(self):
self.patcher = mock.patch.multiple(
'docker.api.client.APIClient',
get=fake_get,
post=fake_post,
put=fake_put,
delete=fake_delete,
_read_from_socket=fake_read_from_socket)
self.patcher.start()
self.client = APIClient(version=DEFAULT_DOCKER_API_VERSION)
def request(self, stream=None, tty=None, demux=None):
assert stream is not None and tty is not None and demux is not None
with APIClient(base_url=self.address) as client:
if tty:
url = client._url('/tty')
else:
url = client._url('/no-tty')
resp = client._post(url, stream=True)
return client._read_from_socket(
resp, stream=stream, tty=tty, demux=demux)
def setUp(self):
self.patcher = mock.patch.multiple(
'docker.api.client.APIClient',
get=fake_get,
post=fake_post,
put=fake_put,
delete=fake_delete,
_read_from_socket=fake_read_from_socket)
self.patcher.start()
self.client = APIClient()
# Force-clear authconfig to avoid tampering with the tests
self.client._cfg = {'Configs': {}}
def setUp(self):
self.client = APIClient()
def test_url_compatibility_http_unix_triple_slash(self):
c = APIClient(
base_url="http+unix:///socket",
version=DEFAULT_DOCKER_API_VERSION)
assert self._socket_path_for_client_session(c) == '/socket'
def test_url_compatibility_tcp(self):
c = APIClient(
base_url="tcp://hostname:1234",
version=DEFAULT_DOCKER_API_VERSION)
assert c.base_url == "http://hostname:1234"
def setUp(self):
self.client = APIClient(version=DEFAULT_DOCKER_API_VERSION)
def test_url_compatibility_tcp(self):
c = APIClient(base_url="tcp://hostname:1234")
assert c.base_url == "http://hostname:1234"
def test_url_compatibility_http_unix_triple_slash(self):
c = APIClient(base_url="http+unix:///socket")
assert self._socket_path_for_client_session(c) == '/socket'
def test_url_compatibility_unix(self):
c = APIClient(base_url="unix://socket")
assert self._socket_path_for_client_session(c) == '/socket'
def test_retrieve_server_version(self):
client = APIClient(version="auto")
assert isinstance(client._version, six.string_types)
assert not (client._version == "auto")
client.close()
def test_retrieve_server_version(self):
client = APIClient(version="auto")
self.assertTrue(isinstance(client._version, six.string_types))
self.assertFalse(client._version == "auto")
client.close()
async def start(self) -> None:
if self._state.container is not None:
# Already started or starting
await self._state.container
return
self._state.container = Deferred()
client = self._dockerClient
imageName = f"{self.imageRepository}:{self.imageTag}"
try:
image = client.images.get(imageName)
except ImageNotFound:
self._log.info("Pulling MySQL image: {name}", name=imageName)
image = await deferToThread(client.images.pull,
self.imageRepository, self.imageTag)
containerName = self._containerName
self._log.info("Creating MySQL container {name}", name=containerName)
container = client.containers.create(
name=containerName,
image=image.id,
auto_remove=True,
detach=True,
environment=self._containerEnvironment,
ports={3306: None},
)
self._log.info("Starting MySQL container {name}", name=containerName)
container.start()
try:
await self._waitOnContainerLog(container,
" starting as process 1 ")
# Clean up the container before the reactor shuts down
reactor.addSystemEventTrigger(
"before", "shutdown",
lambda: self._stop(container, containerName))
apiClient = APIClient()
netloc = apiClient.port(container.id, 3306)[0]
self._state.host = netloc["HostIp"]
self._state.port = int(netloc["HostPort"])
self._log.info("MySQL container {name} ready at: {host}:{port}",
name=containerName,
host=self.host,
port=self.port)
self._log.info(
"docker exec"
" --interactive"
" --tty"
" {container}"
" mysql"
" --host=docker.for.mac.host.internal"
" --port={port}"
" --user=root"
" --password={password}"
"",
container=containerName,
port=self.port,
password=self.rootPassword,
)
self._state.container.callback(container)
except Exception as e:
self._resetContainerState()
self._log.failure(
"Stopping MySQL container {name} due to error: {error}",
name=containerName,
error=e,
)
container.stop()
raise
