def get_deployment(self,
resource_name,
volume_mounts,
volumes,
labels,
env_vars=None,
command=None,
args=None,
ports=None,
persistence_outputs=None,
persistence_data=None,
outputs_refs_jobs=None,
outputs_refs_experiments=None,
secret_refs=None,
configmap_refs=None,
resources=None,
ephemeral_token=None,
node_selector=None,
affinity=None,
tolerations=None,
restart_policy=None,
replicas=1):
deployment_spec = self.get_deployment_spec(
resource_name=resource_name,
volume_mounts=volume_mounts,
volumes=volumes,
labels=labels,
env_vars=env_vars,
command=command,
args=args,
ports=ports,
persistence_outputs=persistence_outputs,
persistence_data=persistence_data,
outputs_refs_jobs=outputs_refs_jobs,
outputs_refs_experiments=outputs_refs_experiments,
secret_refs=secret_refs,
configmap_refs=configmap_refs,
resources=resources,
ephemeral_token=ephemeral_token,
node_selector=node_selector,
affinity=affinity,
tolerations=tolerations,
restart_policy=restart_policy,
replicas=replicas,
)
metadata = client.V1ObjectMeta(name=resource_name, labels=labels, namespace=self.namespace)
return client.AppsV1beta1Deployment(api_version=k8s_constants.K8S_API_VERSION_V1_BETA1,
kind=k8s_constants.K8S_DEPLOYMENT_KIND,
metadata=metadata,
spec=deployment_spec)
def create_deployment_skeleton(namespace, name, replicas):
# Create and configurate a spec section
template = client.V1PodTemplateSpec()
# Create the specification of deployment
spec = client.AppsV1beta1DeploymentSpec(replicas=replicas, template=template)
# Instantiate the deployment object
deployment = client.AppsV1beta1Deployment(
api_version="extensions/v1beta1",
kind="Deployment",
metadata=client.V1ObjectMeta(name=name),
spec=spec,
)
return deployment
def test_service_and_deploy_not_cached_yet_update_exception(
self, mock_list_cluster_memcached_object,
mock_read_namespaced_service, mock_create_service,
mock_cache_version, mock_is_version_cached, mock_update_service,
mock_read_namespaced_deployment, mock_create_mcrouter_deployment,
mock_create_memcached_deployment, mock_update_mcrouter_deployment,
mock_update_memcached_deployment):
# Mock list memcached call with 0 items
mock_list_cluster_memcached_object.return_value = self.base_list_result
check_existing()
mock_list_cluster_memcached_object.assert_called_once_with()
read_namespaced_service_calls = [
call(self.name, self.namespace),
call('{}-backend'.format(self.name), self.namespace)
]
mock_read_namespaced_service.assert_has_calls(
read_namespaced_service_calls)
assert mock_create_service.called is False
assert mock_cache_version.called is False
is_version_cached_calls = [
call(client.V1Service()),
call(client.AppsV1beta1Deployment())
]
mock_is_version_cached.assert_has_calls(is_version_cached_calls)
update_service_calls = [
call(get_mcrouter_service_object(self.cluster_object)),
call(get_memcached_service_object(self.cluster_object))
]
mock_update_service.assert_has_calls(update_service_calls)
read_namespaced_deployment_calls = [
call(self.name, self.namespace),
call('{}-router'.format(self.name), self.namespace)
]
mock_read_namespaced_deployment.assert_has_calls(
read_namespaced_deployment_calls)
assert mock_create_memcached_deployment.called is False
assert mock_create_mcrouter_deployment.called is False
mock_update_memcached_deployment.assert_called_once_with(
self.cluster_object)
mock_update_mcrouter_deployment.assert_called_once_with(
self.cluster_object)
def get_deployment(namespace,
app,
name,
project_name,
project_uuid,
volume_mounts,
volumes,
image,
command,
args,
ports,
container_name,
resources=None,
node_selector=None,
role=None,
type=None, # pylint:disable=redefined-builtin
replicas=1):
labels = get_labels(app=app,
project_name=project_name,
project_uuid=project_uuid,
role=role,
type=type)
metadata = client.V1ObjectMeta(
name=constants.DEPLOYMENT_NAME.format(project_uuid=project_uuid, name=name),
labels=labels,
namespace=namespace)
spec = get_deployment_spec(namespace=namespace,
app=app,
name=name,
project_name=project_name,
project_uuid=project_uuid,
volume_mounts=volume_mounts,
volumes=volumes,
image=image,
command=command,
args=args,
ports=ports,
container_name=container_name,
resources=resources,
node_selector=node_selector,
role=role,
type=type,
replicas=replicas)
return client.AppsV1beta1Deployment(api_version=k8s_constants.K8S_API_VERSION_V1_BETA1,
kind=k8s_constants.K8S_DEPLOYMENT_KIND,
metadata=metadata,
spec=spec)
def create_deployment(parameters):
image_name = parameters['image_name']
deployment_name = image_name
if '_' in image_name:
deployment_name = image_name.replace('_', '')
image_tag = parameters['image_tag']
body = client.AppsV1beta1Deployment()
body.metadata = {
"name": deployment_name,
"labels": {
"app": deployment_name
}
}
body.spec = {
"template": {
"metadata": {
"labels": {
"app": deployment_name
}
},
"spec": {
"containers": [{
"name":
deployment_name,
"image":
"urvil38/{}:{}".format(image_name, image_tag)
}]
}
}
}
speech = ""
try:
response = k8_client.create_namespaced_deployment(namespace, body)
speech = "Deploying {} {} into the {} cluster.".format(
image_name, image_tag, node_name[0])
except ApiException as e:
print(
"Exception when calling AppsV1beta1Api->create_namespaced_deployment: %s\n"
% e)
speech = "There was an error while creating the {} deployment".format(
image_name)
return {"speech": speech, "displayText": speech}
class TestCreateMcrouterDeployment():
def setUp(self):
self.cluster_object = DEPLOYMENT_CLUSTER_OBJECT
self.name = self.cluster_object['metadata']['name']
self.namespace = self.cluster_object['metadata']['namespace']
self.replicas = self.cluster_object['mcrouter']['replicas']
@patch('memcached_operator.memcached_operator.kubernetes_helpers.logging')
@patch('kubernetes.client.AppsV1beta1Api.create_namespaced_deployment',
return_value=client.AppsV1beta1Deployment())
def test_success(self, mock_create_namespaced_deployment, mock_logging):
deployment = create_mcrouter_deployment(self.cluster_object)
body = get_mcrouter_deployment_object(self.cluster_object)
mock_create_namespaced_deployment.assert_called_once_with(
self.namespace, body)
mock_logging.info.assert_called_once_with(
'created deploy/{}-router in ns/{}'.format(self.name,
self.namespace))
assert isinstance(deployment, client.AppsV1beta1Deployment)
@patch('memcached_operator.memcached_operator.kubernetes_helpers.logging')
@patch('kubernetes.client.AppsV1beta1Api.create_namespaced_deployment',
side_effect=client.rest.ApiException(status=409))
def test_already_exists(self, mock_create_namespaced_deployment,
mock_logging):
deployment = create_mcrouter_deployment(self.cluster_object)
mock_logging.debug.assert_called_once_with(
'deploy/{}-router in ns/{} already exists'.format(
self.name, self.namespace))
assert deployment is False
@patch('memcached_operator.memcached_operator.kubernetes_helpers.logging')
@patch('kubernetes.client.AppsV1beta1Api.create_namespaced_deployment',
side_effect=client.rest.ApiException(status=500))
def test_other_rest_exception(self, mock_create_namespaced_deployment,
mock_logging):
deployment = create_mcrouter_deployment(self.cluster_object)
assert mock_logging.exception.called is True
assert deployment is False
def create_deployment_object():
# Configureate Pod template container
container = client.V1Container(
name="nginx",
image="nginx:1.15.4",
ports=[client.V1ContainerPort(container_port=80)])
# Create and configurate a spec section
template = client.V1PodTemplateSpec(
metadata=client.V1ObjectMeta(labels={"app": "nginx"}),
spec=client.V1PodSpec(containers=[container]))
# Create the specification of deployment
spec = client.AppsV1beta1DeploymentSpec(replicas=3, template=template)
# Instantiate the deployment object
deployment = client.AppsV1beta1Deployment(
api_version="apps/v1beta1",
kind="Deployment",
metadata=client.V1ObjectMeta(name=DEPLOYMENT_NAME),
spec=spec)
return deployment
def deployment_definition(self):
return client.AppsV1beta1Deployment(
metadata=client.V1ObjectMeta(
name=self.kube_name,
namespace=settings.kube_namespace,
labels={'pycroservice': settings.kube_namespace},
),
spec=client.AppsV1beta1DeploymentSpec(
replicas=1,
selector=client.V1LabelSelector(
match_labels={'microservice': self.kube_name},
),
template=client.V1PodTemplateSpec(
metadata=client.V1ObjectMeta(
labels={'microservice': self.kube_name},
),
spec=self.pod_spec,
),
)
)
def create_deployment(self,
namespace='default',
name=None,
metadata=None,
spec=None):
'''
Returns AppsV1beta1Deployment object
'''
if metadata is None: metadata = {}
if spec is None: spec = {}
metadata_obj = self._get_metadata(metadata)
if name:
metadata_obj.name = name
spec_obj = self._get_deployment_spec(spec)
body = client.AppsV1beta1Deployment(metadata=metadata_obj,
spec=spec_obj)
self.logger.info('Creating Deployment %s' % (metadata_obj.name))
resp = self.apps_v1_beta1_h.create_namespaced_deployment(
namespace, body)
return resp
def scale_deployment(parameters):
deployment_name = parameters['deployment_name']
replica_count = int(parameters['replica_count'])
body = client.AppsV1beta1Deployment()
body.spec = {"replicas": replica_count}
speech = ""
try:
response = k8_client.patch_namespaced_deployment(
deployment_name, namespace, body)
speech = "Scaling the {} deployment to {}".format(
deployment_name, replica_count)
except ApiException as e:
print(
"Exception when calling AppsV1beta1Api->patch_namespaced_deployment: %s\n"
% e)
speech = "There was an error when scaling {} deployment".format(
deployment_name)
return {"speech": speech, "displayText": speech}
def get_memcached_deployment_object(cluster_object):
name = cluster_object['metadata']['name']
namespace = cluster_object['metadata']['namespace']
try:
replicas = cluster_object['spec']['memcached']['replicas']
except KeyError:
replicas = 2
try:
memcached_limit_cpu = \
cluster_object['spec']['memcached']['memcached_limit_cpu']
except KeyError:
memcached_limit_cpu = '100m'
try:
memcached_limit_memory = \
cluster_object['spec']['memcached']['memcached_limit_memory']
except KeyError:
memcached_limit_memory = '64Mi'
deployment = client.AppsV1beta1Deployment()
# Metadata
deployment.metadata = client.V1ObjectMeta(
name=name, namespace=namespace, labels=get_default_labels(name=name))
deployment.metadata.labels['service-type'] = 'memcached'
# Spec
deployment.spec = client.AppsV1beta1DeploymentSpec(
replicas=replicas, template=client.V1PodTemplateSpec())
deployment.spec.template.metadata = client.V1ObjectMeta(
labels=deployment.metadata.labels)
deployment.spec.template.spec = client.V1PodSpec(containers=[])
# Memcached container
memcached_port = client.V1ContainerPort(name='memcached',
container_port=11211,
protocol='TCP')
memcached_resources = client.V1ResourceRequirements(
limits={
'cpu': memcached_limit_cpu,
'memory': memcached_limit_memory
},
requests={
'cpu': memcached_limit_cpu,
'memory': memcached_limit_memory
})
memcached_container = client.V1Container(
name='memcached',
command=['memcached', '-p', '11211'],
image='memcached:1.4.33',
ports=[memcached_port],
resources=memcached_resources)
# Metrics container
metrics_port = client.V1ContainerPort(name='metrics',
container_port=9150,
protocol='TCP')
metrics_resources = client.V1ResourceRequirements(limits={
'cpu': '50m',
'memory': '16Mi'
},
requests={
'cpu': '50m',
'memory': '16Mi'
})
metrics_container = client.V1Container(
name='prometheus-exporter',
image='prom/memcached-exporter:v0.3.0',
ports=[metrics_port],
resources=metrics_resources)
deployment.spec.template.spec.containers = [
memcached_container, metrics_container
]
return deployment
def get_mcrouter_deployment_object(cluster_object):
name = cluster_object['metadata']['name']
namespace = cluster_object['metadata']['namespace']
try:
replicas = cluster_object['spec']['mcrouter']['replicas']
except KeyError:
replicas = 1
try:
mcrouter_limit_cpu = \
cluster_object['spec']['mcrouter']['mcrouter_limit_cpu']
except KeyError:
mcrouter_limit_cpu = '50m'
try:
mcrouter_limit_memory = \
cluster_object['spec']['mcrouter']['mcrouter_limit_memory']
except KeyError:
mcrouter_limit_memory = '32Mi'
deployment = client.AppsV1beta1Deployment()
# Metadata
deployment.metadata = client.V1ObjectMeta(
name="{}-router".format(name),
namespace=namespace,
labels=get_default_labels(name=name))
deployment.metadata.labels['service-type'] = 'mcrouter'
# Spec
deployment.spec = client.AppsV1beta1DeploymentSpec(
replicas=replicas, template=client.V1PodTemplateSpec())
deployment.spec.template = client.V1PodTemplateSpec()
deployment.spec.template.metadata = client.V1ObjectMeta(
labels=deployment.metadata.labels)
deployment.spec.template.spec = client.V1PodSpec(containers=[])
# Mcrouter container
mcrouter_config_volumemount = client.V1VolumeMount(
name='mcrouter-config', read_only=False, mount_path='/etc/mcrouter')
mcrouter_port = client.V1ContainerPort(name='mcrouter',
container_port=11211,
protocol='TCP')
mcrouter_resources = client.V1ResourceRequirements(
limits={
'cpu': mcrouter_limit_cpu,
'memory': mcrouter_limit_memory
},
requests={
'cpu': mcrouter_limit_cpu,
'memory': mcrouter_limit_memory
})
mcrouter_container = client.V1Container(
name='mcrouter',
command=[
'mcrouter', '-p', '11211', '-f', '/etc/mcrouter/mcrouter.conf'
],
image='kubestack/mcrouter:v0.36.0-kbst1',
ports=[mcrouter_port],
volume_mounts=[mcrouter_config_volumemount],
resources=mcrouter_resources)
# Mcrouter config sidecar
sidecar_resources = client.V1ResourceRequirements(limits={
'cpu': '25m',
'memory': '8Mi'
},
requests={
'cpu': '25m',
'memory': '8Mi'
})
sidecar_config_volumemount = client.V1VolumeMount(
name='mcrouter-config', read_only=True, mount_path='/etc/mcrouter')
sidecar_container = client.V1Container(
name='config-sidecar',
args=[
"--debug", "--output=/etc/mcrouter/mcrouter.conf",
"{}-backend.{}.svc.cluster.local".format(name, namespace)
],
image='kubestack/mcrouter_sidecar:v0.1.0',
volume_mounts=[mcrouter_config_volumemount],
resources=sidecar_resources)
# Config Map Volume
mcrouter_config_volume = client.V1Volume(
name='mcrouter-config', empty_dir=client.V1EmptyDirVolumeSource())
deployment.spec.template.spec.volumes = [mcrouter_config_volume]
# Metrics container
metrics_port = client.V1ContainerPort(name='metrics',
container_port=9150,
protocol='TCP')
metrics_resources = client.V1ResourceRequirements(limits={
'cpu': '50m',
'memory': '16Mi'
},
requests={
'cpu': '50m',
'memory': '16Mi'
})
metrics_container = client.V1Container(
name='prometheus-exporter',
image='kubestack/mcrouter_exporter:v0.0.1',
args=[
'-mcrouter.address', 'localhost:11211', '-web.listen-address',
':9150'
],
ports=[metrics_port],
resources=metrics_resources)
deployment.spec.template.spec.containers = [
mcrouter_container, sidecar_container, metrics_container
]
return deployment
class TestCheckExisting():
def setUp(self):
self.name = 'testname123'
self.namespace = 'testnamespace456'
self.cluster_object = {
'metadata': {
'name': self.name,
'namespace': self.namespace
}
}
self.base_list_result = {'items': [self.cluster_object]}
@patch('memcached_operator.memcached_operator.periodical.logging')
@patch(
'memcached_operator.memcached_operator.periodical.list_cluster_memcached_object',
side_effect=client.rest.ApiException())
def test_list_memcached_exception(self, mock_list_cluster_memcached_object,
mock_logging):
result = check_existing()
assert mock_logging.exception.called is True
assert result is False
@patch(
'memcached_operator.memcached_operator.periodical.update_memcached_deployment'
)
@patch(
'memcached_operator.memcached_operator.periodical.update_mcrouter_deployment'
)
@patch(
'memcached_operator.memcached_operator.periodical.create_memcached_deployment'
)
@patch(
'memcached_operator.memcached_operator.periodical.create_mcrouter_deployment'
)
@patch('kubernetes.client.AppsV1beta1Api.read_namespaced_deployment')
@patch('memcached_operator.memcached_operator.periodical.update_service')
@patch('memcached_operator.memcached_operator.periodical.is_version_cached'
)
@patch('memcached_operator.memcached_operator.periodical.cache_version')
@patch('memcached_operator.memcached_operator.periodical.create_service')
@patch('kubernetes.client.CoreV1Api.read_namespaced_service')
@patch(
'memcached_operator.memcached_operator.periodical.list_cluster_memcached_object'
)
def test_no_memcached_tprs(
self, mock_list_cluster_memcached_object,
mock_read_namespaced_service, mock_create_service,
mock_cache_version, mock_is_version_cached, mock_update_service,
mock_read_namespaced_deployment, mock_create_mcrouter_deployment,
mock_create_memcached_deployment, mock_update_mcrouter_deployment,
mock_update_memcached_deployment):
# Mock list memcached call with 0 items
no_item_result = deepcopy(self.base_list_result)
no_item_result['items'] = []
mock_list_cluster_memcached_object.return_value = no_item_result
check_existing()
mock_list_cluster_memcached_object.assert_called_once_with()
assert mock_read_namespaced_service.called is False
assert mock_create_service.called is False
assert mock_cache_version.called is False
assert mock_is_version_cached.called is False
assert mock_update_service.called is False
assert mock_read_namespaced_deployment.called is False
assert mock_create_memcached_deployment.called is False
assert mock_create_mcrouter_deployment.called is False
assert mock_update_memcached_deployment.called is False
assert mock_update_memcached_deployment.called is False
@patch(
'memcached_operator.memcached_operator.periodical.update_memcached_deployment'
)
@patch(
'memcached_operator.memcached_operator.periodical.update_mcrouter_deployment'
)
@patch(
'memcached_operator.memcached_operator.periodical.create_memcached_deployment',
return_value=client.AppsV1beta1Deployment())
@patch(
'memcached_operator.memcached_operator.periodical.create_mcrouter_deployment',
return_value=client.AppsV1beta1Deployment())
@patch('kubernetes.client.AppsV1beta1Api.read_namespaced_deployment',
side_effect=client.rest.ApiException(status=404))
@patch('memcached_operator.memcached_operator.periodical.update_service')
@patch(
'memcached_operator.memcached_operator.periodical.is_version_cached',
return_value=True)
@patch('memcached_operator.memcached_operator.periodical.cache_version')
@patch('memcached_operator.memcached_operator.periodical.create_service',
return_value=client.V1Service())
@patch('kubernetes.client.CoreV1Api.read_namespaced_service',
side_effect=client.rest.ApiException(status=404))
@patch(
'memcached_operator.memcached_operator.periodical.list_cluster_memcached_object'
)
def test_service_and_deploy_404(
self, mock_list_cluster_memcached_object,
mock_read_namespaced_service, mock_create_service,
mock_cache_version, mock_is_version_cached, mock_update_service,
mock_read_namespaced_deployment, mock_create_mcrouter_deployment,
mock_create_memcached_deployment, mock_update_mcrouter_deployment,
mock_update_memcached_deployment):
# Mock list memcached call with 0 items
mock_list_cluster_memcached_object.return_value = self.base_list_result
check_existing()
mock_list_cluster_memcached_object.assert_called_once_with()
service_calls = [
call(self.name, self.namespace),
call('{}-backend'.format(self.name), self.namespace)
]
mock_read_namespaced_service.assert_has_calls(service_calls)
create_service_calls = [
call(get_mcrouter_service_object(self.cluster_object)),
call(get_memcached_service_object(self.cluster_object))
]
mock_create_service.assert_has_calls(create_service_calls)
cache_version_calls = [
call(client.V1Service()),
call(client.AppsV1beta1Deployment())
]
mock_cache_version.assert_has_calls(cache_version_calls)
assert mock_is_version_cached.called is False
assert mock_update_service.called is False
read_namespaced_deployment_calls = [
call(self.name, self.namespace),
call('{}-router'.format(self.name), self.namespace)
]
mock_read_namespaced_deployment.assert_has_calls(
read_namespaced_deployment_calls)
mock_create_memcached_deployment.assert_called_once_with(
self.cluster_object)
mock_create_mcrouter_deployment.assert_called_once_with(
self.cluster_object)
assert mock_update_memcached_deployment.called is False
assert mock_update_mcrouter_deployment.called is False
@patch(
'memcached_operator.memcached_operator.periodical.update_memcached_deployment'
)
@patch(
'memcached_operator.memcached_operator.periodical.update_mcrouter_deployment'
)
@patch(
'memcached_operator.memcached_operator.periodical.create_memcached_deployment',
return_value=False)
@patch(
'memcached_operator.memcached_operator.periodical.create_mcrouter_deployment',
return_value=False)
@patch('kubernetes.client.AppsV1beta1Api.read_namespaced_deployment',
side_effect=client.rest.ApiException(status=404))
@patch('memcached_operator.memcached_operator.periodical.update_service')
@patch(
'memcached_operator.memcached_operator.periodical.is_version_cached',
return_value=True)
@patch('memcached_operator.memcached_operator.periodical.cache_version')
@patch('memcached_operator.memcached_operator.periodical.create_service',
return_value=False)
@patch('kubernetes.client.CoreV1Api.read_namespaced_service',
side_effect=client.rest.ApiException(status=404))
@patch(
'memcached_operator.memcached_operator.periodical.list_cluster_memcached_object'
)
def test_service_and_deploy_404_yet_create_false(
self, mock_list_cluster_memcached_object,
mock_read_namespaced_service, mock_create_service,
mock_cache_version, mock_is_version_cached, mock_update_service,
mock_read_namespaced_deployment, mock_create_mcrouter_deployment,
mock_create_memcached_deployment, mock_update_mcrouter_deployment,
mock_update_memcached_deployment):
# Mock list memcached call with 0 items
mock_list_cluster_memcached_object.return_value = self.base_list_result
check_existing()
mock_list_cluster_memcached_object.assert_called_once_with()
read_service_calls = [
call(self.name, self.namespace),
call('{}-backend'.format(self.name), self.namespace)
]
mock_read_namespaced_service.assert_has_calls(read_service_calls)
create_service_calls = [
call(get_mcrouter_service_object(self.cluster_object)),
call(get_memcached_service_object(self.cluster_object))
]
mock_create_service.assert_has_calls(create_service_calls)
assert mock_cache_version.called is False
assert mock_is_version_cached.called is False
assert mock_update_service.called is False
read_namespaced_deployment_calls = [
call(self.name, self.namespace),
call('{}-router'.format(self.name), self.namespace)
]
mock_read_namespaced_deployment.assert_has_calls(
read_namespaced_deployment_calls)
mock_create_memcached_deployment.assert_called_once_with(
self.cluster_object)
mock_create_mcrouter_deployment.assert_called_once_with(
self.cluster_object)
assert mock_update_memcached_deployment.called is False
assert mock_update_mcrouter_deployment.called is False
@patch('memcached_operator.memcached_operator.periodical.logging')
@patch(
'memcached_operator.memcached_operator.periodical.update_memcached_deployment'
)
@patch(
'memcached_operator.memcached_operator.periodical.update_mcrouter_deployment'
)
@patch(
'memcached_operator.memcached_operator.periodical.create_memcached_deployment'
)
@patch(
'memcached_operator.memcached_operator.periodical.create_mcrouter_deployment'
)
@patch('kubernetes.client.AppsV1beta1Api.read_namespaced_deployment',
side_effect=client.rest.ApiException(status=500))
@patch('memcached_operator.memcached_operator.periodical.update_service')
@patch('memcached_operator.memcached_operator.periodical.is_version_cached'
)
@patch('memcached_operator.memcached_operator.periodical.cache_version')
@patch('memcached_operator.memcached_operator.periodical.create_service')
@patch('kubernetes.client.CoreV1Api.read_namespaced_service',
side_effect=client.rest.ApiException(status=500))
@patch(
'memcached_operator.memcached_operator.periodical.list_cluster_memcached_object'
)
def test_service_and_deploy_500(
self, mock_list_cluster_memcached_object,
mock_read_namespaced_service, mock_create_service,
mock_cache_version, mock_is_version_cached, mock_update_service,
mock_read_namespaced_deployment, mock_create_mcrouter_deployment,
mock_create_memcached_deployment, mock_update_mcrouter_deployment,
mock_update_memcached_deployment, mock_logging):
# Mock list memcached call
mock_list_cluster_memcached_object.return_value = self.base_list_result
check_existing()
mock_list_cluster_memcached_object.assert_called_once_with()
read_namespaced_service_calls = [
call(self.name, self.namespace),
call('{}-backend'.format(self.name), self.namespace)
]
mock_read_namespaced_service.assert_has_calls(
read_namespaced_service_calls)
assert mock_create_service.called is False
assert mock_cache_version.called is False
assert mock_is_version_cached.called is False
assert mock_update_service.called is False
read_namespaced_deployment_calls = [
call(self.name, self.namespace),
call('{}-router'.format(self.name), self.namespace)
]
mock_read_namespaced_deployment.assert_has_calls(
read_namespaced_deployment_calls)
assert mock_create_memcached_deployment.called is False
assert mock_create_mcrouter_deployment.called is False
assert mock_update_memcached_deployment.called is False
assert mock_update_mcrouter_deployment.called is False
mock_logging.exception.call_count == 2
@patch(
'memcached_operator.memcached_operator.periodical.update_memcached_deployment'
)
@patch(
'memcached_operator.memcached_operator.periodical.update_mcrouter_deployment'
)
@patch(
'memcached_operator.memcached_operator.periodical.create_memcached_deployment'
)
@patch(
'memcached_operator.memcached_operator.periodical.create_mcrouter_deployment'
)
@patch('kubernetes.client.AppsV1beta1Api.read_namespaced_deployment',
return_value=client.AppsV1beta1Deployment())
@patch('memcached_operator.memcached_operator.periodical.update_service')
@patch(
'memcached_operator.memcached_operator.periodical.is_version_cached',
return_value=True)
@patch('memcached_operator.memcached_operator.periodical.cache_version')
@patch('memcached_operator.memcached_operator.periodical.create_service')
@patch('kubernetes.client.CoreV1Api.read_namespaced_service',
return_value=client.V1Service())
@patch(
'memcached_operator.memcached_operator.periodical.list_cluster_memcached_object'
)
def test_service_and_deploy_cached(
self, mock_list_cluster_memcached_object,
mock_read_namespaced_service, mock_create_service,
mock_cache_version, mock_is_version_cached, mock_update_service,
mock_read_namespaced_deployment, mock_create_mcrouter_deployment,
mock_create_memcached_deployment, mock_update_mcrouter_deployment,
mock_update_memcached_deployment):
# Mock list memcached call with 0 items
mock_list_cluster_memcached_object.return_value = self.base_list_result
check_existing()
mock_list_cluster_memcached_object.assert_called_once_with()
read_namespaced_service_calls = [
call(self.name, self.namespace),
call('{}-backend'.format(self.name), self.namespace)
]
mock_read_namespaced_service.assert_has_calls(
read_namespaced_service_calls)
assert mock_create_service.called is False
assert mock_cache_version.called is False
is_version_cached_calls = [
call(client.V1Service()),
call(client.AppsV1beta1Deployment())
]
mock_is_version_cached.assert_has_calls(is_version_cached_calls)
assert mock_update_service.called is False
read_namespaced_deployment_calls = [
call(self.name, self.namespace),
call('{}-router'.format(self.name), self.namespace)
]
mock_read_namespaced_deployment.assert_has_calls(
read_namespaced_deployment_calls)
assert mock_create_memcached_deployment.called is False
assert mock_create_mcrouter_deployment.called is False
assert mock_update_memcached_deployment.called is False
assert mock_update_mcrouter_deployment.called is False
@patch(
'memcached_operator.memcached_operator.periodical.update_memcached_deployment',
return_value=client.AppsV1beta1Deployment())
@patch(
'memcached_operator.memcached_operator.periodical.update_mcrouter_deployment',
return_value=client.AppsV1beta1Deployment())
@patch(
'memcached_operator.memcached_operator.periodical.create_memcached_deployment'
)
@patch(
'memcached_operator.memcached_operator.periodical.create_mcrouter_deployment'
)
@patch('kubernetes.client.AppsV1beta1Api.read_namespaced_deployment',
return_value=client.AppsV1beta1Deployment())
@patch('memcached_operator.memcached_operator.periodical.update_service',
return_value=client.V1Service())
@patch(
'memcached_operator.memcached_operator.periodical.is_version_cached',
return_value=False)
@patch('memcached_operator.memcached_operator.periodical.cache_version')
@patch('memcached_operator.memcached_operator.periodical.create_service')
@patch('kubernetes.client.CoreV1Api.read_namespaced_service',
return_value=client.V1Service())
@patch(
'memcached_operator.memcached_operator.periodical.list_cluster_memcached_object'
)
def test_service_and_deploy_not_cached(
self, mock_list_cluster_memcached_object,
mock_read_namespaced_service, mock_create_service,
mock_cache_version, mock_is_version_cached, mock_update_service,
mock_read_namespaced_deployment, mock_create_mcrouter_deployment,
mock_create_memcached_deployment, mock_update_mcrouter_deployment,
mock_update_memcached_deployment):
# Mock list memcached call with 0 items
mock_list_cluster_memcached_object.return_value = self.base_list_result
check_existing()
mock_list_cluster_memcached_object.assert_called_once_with()
read_namespaced_service_calls = [
call(self.name, self.namespace),
call('{}-backend'.format(self.name), self.namespace)
]
mock_read_namespaced_service.assert_has_calls(
read_namespaced_service_calls)
assert mock_create_service.called is False
cache_version_calls = [
call(client.V1Service()),
call(client.AppsV1beta1Deployment())
]
mock_cache_version.assert_has_calls(cache_version_calls)
is_version_cached_calls = [
call(client.V1Service()),
call(client.AppsV1beta1Deployment())
]
mock_is_version_cached.assert_has_calls(is_version_cached_calls)
update_service_calls = [
call(get_mcrouter_service_object(self.cluster_object)),
call(get_memcached_service_object(self.cluster_object))
]
mock_update_service.assert_has_calls(update_service_calls)
read_namespaced_deployment_calls = [
call(self.name, self.namespace),
call('{}-router'.format(self.name), self.namespace)
]
mock_read_namespaced_deployment.assert_has_calls(
read_namespaced_deployment_calls)
assert mock_create_memcached_deployment.called is False
assert mock_create_mcrouter_deployment.called is False
mock_update_memcached_deployment.assert_called_once_with(
self.cluster_object)
mock_update_mcrouter_deployment.assert_called_once_with(
self.cluster_object)
@patch(
'memcached_operator.memcached_operator.periodical.update_memcached_deployment',
return_value=False)
@patch(
'memcached_operator.memcached_operator.periodical.update_mcrouter_deployment',
return_value=False)
@patch(
'memcached_operator.memcached_operator.periodical.create_memcached_deployment'
)
@patch(
'memcached_operator.memcached_operator.periodical.create_mcrouter_deployment'
)
@patch('kubernetes.client.AppsV1beta1Api.read_namespaced_deployment',
return_value=client.AppsV1beta1Deployment())
@patch('memcached_operator.memcached_operator.periodical.update_service',
return_value=False)
@patch(
'memcached_operator.memcached_operator.periodical.is_version_cached',
return_value=False)
@patch('memcached_operator.memcached_operator.periodical.cache_version')
@patch('memcached_operator.memcached_operator.periodical.create_service')
@patch('kubernetes.client.CoreV1Api.read_namespaced_service',
return_value=client.V1Service())
@patch(
'memcached_operator.memcached_operator.periodical.list_cluster_memcached_object'
)
def test_service_and_deploy_not_cached_yet_update_exception(
self, mock_list_cluster_memcached_object,
mock_read_namespaced_service, mock_create_service,
mock_cache_version, mock_is_version_cached, mock_update_service,
mock_read_namespaced_deployment, mock_create_mcrouter_deployment,
mock_create_memcached_deployment, mock_update_mcrouter_deployment,
mock_update_memcached_deployment):
# Mock list memcached call with 0 items
mock_list_cluster_memcached_object.return_value = self.base_list_result
check_existing()
mock_list_cluster_memcached_object.assert_called_once_with()
read_namespaced_service_calls = [
call(self.name, self.namespace),
call('{}-backend'.format(self.name), self.namespace)
]
mock_read_namespaced_service.assert_has_calls(
read_namespaced_service_calls)
assert mock_create_service.called is False
assert mock_cache_version.called is False
is_version_cached_calls = [
call(client.V1Service()),
call(client.AppsV1beta1Deployment())
]
mock_is_version_cached.assert_has_calls(is_version_cached_calls)
update_service_calls = [
call(get_mcrouter_service_object(self.cluster_object)),
call(get_memcached_service_object(self.cluster_object))
]
mock_update_service.assert_has_calls(update_service_calls)
read_namespaced_deployment_calls = [
call(self.name, self.namespace),
call('{}-router'.format(self.name), self.namespace)
]
mock_read_namespaced_deployment.assert_has_calls(
read_namespaced_deployment_calls)
assert mock_create_memcached_deployment.called is False
assert mock_create_mcrouter_deployment.called is False
mock_update_memcached_deployment.assert_called_once_with(
self.cluster_object)
mock_update_mcrouter_deployment.assert_called_once_with(
self.cluster_object)
def get_deployment(
namespace,
app,
name,
project_name,
project_uuid,
job_name,
job_uuid,
volume_mounts,
volumes,
image,
command,
args,
ports,
container_name,
env_vars=None,
env_from=None,
resources=None,
node_selector=None,
affinity=None,
tolerations=None,
role=None,
type=None, # pylint:disable=redefined-builtin
replicas=1,
service_account_name=None):
labels = get_labels(app=app,
project_name=project_name,
project_uuid=project_uuid,
job_name=job_name,
job_uuid=job_uuid,
role=role,
type=type)
metadata = client.V1ObjectMeta(name=JOB_NAME_FORMAT.format(
name=name, job_uuid=job_uuid),
labels=labels,
namespace=namespace)
spec = get_deployment_spec(namespace=namespace,
app=app,
name=name,
project_name=project_name,
project_uuid=project_uuid,
job_name=job_name,
job_uuid=job_uuid,
volume_mounts=volume_mounts,
volumes=volumes,
image=image,
command=command,
args=args,
ports=ports,
env_vars=env_vars,
env_from=env_from,
container_name=container_name,
resources=resources,
node_selector=node_selector,
affinity=affinity,
tolerations=tolerations,
role=role,
type=type,
replicas=replicas,
service_account_name=service_account_name)
return client.AppsV1beta1Deployment(
api_version=k8s_constants.K8S_API_VERSION_EXTENSIONS_V1_BETA1,
kind=k8s_constants.K8S_DEPLOYMENT_KIND,
metadata=metadata,
spec=spec)
logging.getLogger().setLevel('DEBUG')
konfig.load_incluster_config()
cl = klient.AppsV1beta1Api()
# READ DEPLOYMENT:
depl = cl.read_namespaced_deployment(
name='pynsider',
namespace='default',
pretty='yeshh',
)
logging.info(depl.metadata)
# UPDATE DEPLOYMENT:
nd = klient.AppsV1beta1Deployment()
nd.api_version = depl.api_version
nd.kind = depl.kind
nd.metadata = depl.metadata
nd.metadata.annotations['CHRISTOULAS'] = '42 re malakes'
nd.spec = depl.spec
new_depl = cl.replace_namespaced_deployment(
name='pynsider',
namespace='default',
body=nd,
pretty='yup',
)
def get_deployment(self,
resource_name,
volume_mounts,
volumes,
labels,
env_vars=None,
command=None,
args=None,
init_command=None,
init_args=None,
init_env_vars=None,
ports=None,
persistence_outputs=None,
persistence_data=None,
outputs_refs_jobs=None,
outputs_refs_experiments=None,
secret_refs=None,
config_map_refs=None,
resources=None,
annotations=None,
ephemeral_token=None,
node_selector=None,
affinity=None,
tolerations=None,
max_restarts=None,
restart_policy=None,
reconcile_url=None,
init_context_mounts=None,
sidecar_context_mounts=None,
replicas=1):
template_spec = self.get_pod_template_spec(
resource_name=resource_name,
volume_mounts=volume_mounts,
volumes=volumes,
labels=labels,
env_vars=env_vars,
command=command,
args=args,
init_command=init_command,
init_args=init_args,
init_env_vars=init_env_vars,
ports=ports,
persistence_outputs=persistence_outputs,
persistence_data=persistence_data,
outputs_refs_jobs=outputs_refs_jobs,
outputs_refs_experiments=outputs_refs_experiments,
secret_refs=secret_refs,
config_map_refs=config_map_refs,
resources=resources,
annotations=annotations,
ephemeral_token=ephemeral_token,
node_selector=node_selector,
affinity=affinity,
tolerations=tolerations,
max_restarts=max_restarts,
restart_policy=restart_policy,
reconcile_url=reconcile_url,
init_context_mounts=init_context_mounts,
sidecar_context_mounts=sidecar_context_mounts,
)
deployment_spec = client.AppsV1beta1DeploymentSpec(
replicas=replicas, template=template_spec)
metadata = client.V1ObjectMeta(name=resource_name,
labels=labels,
namespace=self.namespace)
return client.AppsV1beta1Deployment(
api_version=k8s_constants.K8S_API_VERSION_APPS_V1,
kind=k8s_constants.K8S_DEPLOYMENT_KIND,
metadata=metadata,
spec=deployment_spec)
