def test___init___with_tls(self):
# setUp method called it
self.client_cls.reset_mock()
from docker import tls
p_mock_tls = mock.patch.object(tls, "TLSConfig")
mock_tls = p_mock_tls.start()
self.addCleanup(p_mock_tls.stop)
timeout = 1
spec = {
"tls_verify": True,
"cert_path": "/foo",
"host": "localhost",
"timeout": timeout
}
service.Docker(spec)
mock_tls.assert_called_once_with(assert_hostname=False,
ca_cert="/foo/ca.pem",
client_cert=("/foo/cert.pem",
"/foo/key.pem"),
ssl_version=None,
verify=True)
self.client_cls.assert_called_once_with(base_url="localhost",
timeout=timeout,
tls=mock_tls.return_value,
version="auto")
def cleanup(spec, names=None, superclass=plugin.Plugin, owner_id=None):
"""Generic cleaner.
This method goes through all plugins. Filter those and left only plugins
with _service from services or _resource from resources.
:param spec: a spec for Docker client
:param names: Use only resource managers that have names in this list.
:param superclass: The plugin superclass to perform cleanup
for. E.g., this could be
``rally.task.scenario.Scenario`` to cleanup all
Scenario resources.
:param owner_id: The UUID of an owner of resource. If it was created at
workload level, it should be workload UUID. If it was created at
subtask level, it should be subtask UUID.
"""
resource_classes = [
cls for cls in discover.itersubclasses(superclass)
if issubclass(cls, rutils.RandomNameGeneratorMixin)
]
if not resource_classes and issubclass(superclass,
rutils.RandomNameGeneratorMixin):
resource_classes.append(superclass)
docker = service.Docker(spec)
for manager in find_resource_managers(names):
LOG.debug("Cleaning up docker %s objects" % manager._name)
SeekAndDestroy(manager,
docker,
resource_classes=resource_classes,
owner_id=owner_id).exterminate()
def __init__(self, context=None):
super(BaseDockerScenario, self).__init__(context)
if "env" in self.context:
self.client = service.Docker(
self.context["env"]["platforms"]["docker"],
atomic_inst=self.atomic_actions(),
name_generator=self.generate_random_name)
def __init__(self, ctx):
super(BaseDockerContext, self).__init__(ctx)
self.context.setdefault("docker", {})
self.client = service.Docker(
self.context["env"]["platforms"]["docker"],
atomic_inst=self.atomic_actions(),
name_generator=self.generate_random_name
)
def check_health(self):
"""Check whatever platform is alive."""
try:
service.Docker(self.platform_data).get_info()
except Exception:
return {
"available": False,
"message": "Something went wrong",
"traceback": traceback.format_exc()
}
return {"available": True}
def setUp(self):
super(DockerServiceTestCase, self).setUp()
import docker
p_mock_client = mock.patch.object(docker, "DockerClient")
self.client_cls = p_mock_client.start()
self.client = self.client_cls.return_value
self.addCleanup(p_mock_client.stop)
self.name_generator = mock.MagicMock()
self.docker = service.Docker({}, name_generator=self.name_generator)
def test___init___without_tls(self):
# setUp method called it
self.client_cls.reset_mock()
from docker import tls
p_mock_tls = mock.patch.object(tls, "TLSConfig")
mock_tls = p_mock_tls.start()
self.addCleanup(p_mock_tls.stop)
spec = {}
service.Docker(spec)
self.assertFalse(mock_tls.called)
self.client_cls.assert_called_once_with(base_url=None,
timeout=60,
tls=False,
version='auto')
def info(self):
"""Return an info about Docker server."""
return {"info": service.Docker(self.platform_data).get_info()}