def test_rollback_no_args(self):
name = "nginx"
image1 = "nginx:1.7.9"
image2 = "nginx:1.9.1"
container = utils.create_container(name=name, image=image1)
dep_name = "yodep-{0}".format(str(uuid.uuid4()))
dep = utils.create_deployment(name=dep_name)
dep.add_container(container)
dep.desired_replicas = 3
if utils.is_reachable(dep.config.api_host):
dep.create()
self.assertEqual(image1, dep.containers[0].image)
dep.container_image = (name, image2)
dep.update()
self.assertIn('deployment.kubernetes.io/revision', dep.annotations)
rev_before = dep.get_annotation(
'deployment.kubernetes.io/revision')
self.assertNotEqual(image1, dep.containers[0].image)
self.assertEqual(image2, dep.containers[0].image)
dep.rollback()
self.assertIn('deployment.kubernetes.io/revision', dep.annotations)
rev_after = dep.get_annotation('deployment.kubernetes.io/revision')
self.assertNotEqual(rev_before, rev_after)
self.assertGreater(rev_after, rev_before)
self.assertEqual(image1, dep.containers[0].image)
self.assertNotEqual(image2, dep.containers[0].image)
def test_get_by_name_nonexistent(self):
name = "yodep-{0}".format(str(uuid.uuid4()))
dep = utils.create_deployment(name=name)
if utils.is_reachable(dep.config.api_host):
result = K8sDeployment.get_by_name(config=dep.config, name=name)
self.assertIsInstance(result, list)
self.assertEqual(0, len(result))
def test_pod_emptydir(self):
container_name = "nginx"
container_image = "nginx:1.7.9"
container = utils.create_container(name=container_name, image=container_image)
vol_name = "emptydir"
vol_type = "emptyDir"
vol_mount = "/test-emptydir"
volume = utils.create_volume(name=vol_name, type=vol_type, mount_path=vol_mount)
container.add_volume_mount(volume)
pod_name = "nginx"
pod = utils.create_pod(name=pod_name)
pod.add_volume(volume)
pod.add_container(container)
if utils.is_reachable(pod.config.api_host):
pod.create()
vols = pod.model.model['spec']['volumes']
volnames = [x['name'] for x in vols]
self.assertIn(vol_name, volnames)
vols = pod.model.pod_spec.model['volumes']
volnames = [x['name'] for x in vols]
self.assertIn(vol_name, volnames)
self.assertEqual(1, len(pod.model.model['spec']['containers']))
mounts = pod.model.model['spec']['containers'][0]['volumeMounts']
mountnames = [x['name'] for x in mounts]
self.assertIn(vol_name, mountnames)
self.assertEqual(1, len(pod.model.pod_spec.model['containers']))
mounts = pod.model.pod_spec.model['containers'][0]['volumeMounts']
mountnames = [x['name'] for x in mounts]
self.assertIn(vol_name, mountnames)
def test_list_nonexistent(self):
name = "yodep-{0}".format(str(uuid.uuid4()))
dep = utils.create_deployment(name=name)
if utils.is_reachable(dep.config.api_host):
objs = dep.list()
self.assertIsInstance(objs, list)
self.assertEqual(0, len(objs))
def test_get_by_name_nonexistent(self):
name = "yodep-{0}".format(str(uuid.uuid4()))
dep = utils.create_deployment(name=name)
if utils.is_reachable(dep.config.api_host):
result = K8sDeployment.get_by_name(config=dep.config, name=name)
self.assertIsInstance(result, list)
self.assertEqual(0, len(result))
def test_api_create(self):
ds = DaemonSet(utils.fluentd_daemonset())
k8s_ds = utils.create_daemonset(name=ds.name)
k8s_ds.model = ds
if utils.is_reachable(k8s_ds.config.api_host):
k8s_ds.create()
self.assertIsInstance(k8s_ds, K8sDaemonSet)
def test_list_nonexistent(self):
name = "yodep-{0}".format(str(uuid.uuid4()))
dep = utils.create_deployment(name=name)
if utils.is_reachable(dep.config.api_host):
objs = dep.list()
self.assertIsInstance(objs, list)
self.assertEqual(0, len(objs))
def test_create(self):
name = "mnubo.com-sa-{0}".format(str(uuid.uuid4().get_hex()[:5]))
acct = utils.create_service_account(name=name)
if utils.is_reachable(acct.config.api_host):
acct.create()
from_get = acct.get()
self.assertEqual(acct, from_get)
def test_delete(self):
name = "yoname"
rs = utils.create_rs(name=name)
config = utils.create_config()
if utils.is_reachable(config.api_host):
utils.cleanup_rs()
result = rs.list()
self.assertIsInstance(result, list)
self.assertEqual(0, len(result))
def test_delete_nonexistent(self):
name = "yorc-{0}".format(str(uuid.uuid4()))
dep = utils.create_deployment(name=name)
if utils.is_reachable(dep.config.api_host):
try:
dep.delete()
self.fail("Should not fail.")
except Exception as err:
self.assertIsInstance(err, NotFoundException)
def test_add_api_token(self):
name = "mnubo.com-sa-{0}".format(str(uuid.uuid4().get_hex()[:5]))
acct = utils.create_service_account(name=name)
if utils.is_reachable(acct.config.api_host):
acct.create()
acct.add_api_token()
secrets = K8sSecret.api_tokens_for_service_account(
config=acct.config, name=acct.name)
self.assertEqual(2, len(secrets))
def test_delete(self):
name = "yoname"
rs = utils.create_rs(name=name)
config = utils.create_config()
if utils.is_reachable(config.api_host):
utils.cleanup_rs()
result = rs.list()
self.assertIsInstance(result, list)
self.assertEqual(0, len(result))
def test_delete_nonexistent(self):
name = "yorc-{0}".format(str(uuid.uuid4()))
dep = utils.create_deployment(name=name)
if utils.is_reachable(dep.config.api_host):
try:
dep.delete()
self.fail("Should not fail.")
except Exception as err:
self.assertIsInstance(err, NotFoundException)
def test_rc_aws_ebs(self):
# http://kubernetes.io/docs/user-guide/volumes/#awselasticblockstore
# - the nodes on which pods are running must be AWS EC2 instances
# - those instances need to be in the same region and availability-zone as the EBS volume
# - EBS only supports a single EC2 instance mounting a volume
# Pod creation will timeout waiting for readiness if not on AWS; unschedulable.
container_name = "nginx"
container_image = "nginx:1.7.9"
container_nginx = utils.create_container(name=container_name, image=container_image)
container_name = "redis"
container_image = "redis:3.0.7"
container_redis = utils.create_container(name=container_name, image=container_image)
volume_id = "vol-0e3056a2"
vol_name = "ebs"
vol_type = "awsElasticBlockStore"
vol_mount = "/test-aws-ebs"
volume = utils.create_volume(name=vol_name, type=vol_type, mount_path=vol_mount)
volume.set_volume_id(volume_id)
container_nginx.add_volume_mount(volume)
container_redis.add_volume_mount(volume)
rc_name = "nginx-{0}".format(str(uuid.uuid4()))
rc = utils.create_rc(name=rc_name)
rc.add_volume(volume)
rc.add_container(container_nginx)
rc.add_container(container_redis)
rc.set_replicas(3)
if utils.is_reachable(rc.config.api_host):
try:
rc.create()
vols = rc.model.model['spec']['template']['spec']['volumes']
volnames = [x['name'] for x in vols]
self.assertIn(vol_name, volnames)
vols = rc.model.pod_spec.model['volumes']
volnames = [x['name'] for x in vols]
self.assertIn(vol_name, volnames)
self.assertEqual(2, len(rc.model.model['spec']['template']['spec']['containers']))
mounts = rc.model.model['spec']['template']['spec']['containers'][0]['volumeMounts']
mountnames = [x['name'] for x in mounts]
self.assertIn(vol_name, mountnames)
self.assertEqual(2, len(rc.model.pod_spec.model['containers']))
mounts = rc.model.pod_spec.model['containers'][0]['volumeMounts']
mountnames = [x['name'] for x in mounts]
self.assertIn(vol_name, mountnames)
except Exception as err:
self.assertIsInstance(err, TimedOutException)
def test_stateful_nginx(self):
svc = Service(headless_service())
sset = StatefulSet(stateful_set())
k8s_svc = K8sService(name='headless')
k8s_sset = K8sStatefulSet(name='sset')
k8s_svc.model = svc
k8s_sset.model = sset
if utils.is_reachable(k8s_svc.config.api_host):
k8s_svc.create()
k8s_sset.create()
def test_rc_gce_pd(self):
# http://kubernetes.io/docs/user-guide/volumes/#gcepersistentdisk
# - the nodes on which pods are running must be GCE VMs
# - those VMs need to be in the same GCE project and zone as the PD
# Pod creation will timeout waiting for readiness if not on GCE; unschedulable.
container_name = "nginx"
container_image = "nginx:1.7.9"
container_nginx = utils.create_container(name=container_name, image=container_image)
container_name = "redis"
container_image = "redis:3.0.7"
container_redis = utils.create_container(name=container_name, image=container_image)
pd_name = "kubernetes-py-test-pd"
vol_name = "persistent"
vol_type = "gcePersistentDisk"
vol_mount = "/test-gce-pd"
volume = utils.create_volume(name=vol_name, type=vol_type, mount_path=vol_mount, read_only=True)
volume.set_pd_name(pd_name)
container_nginx.add_volume_mount(volume)
container_redis.add_volume_mount(volume)
rc_name = "nginx-{0}".format(str(uuid.uuid4()))
rc = utils.create_rc(name=rc_name)
rc.add_volume(volume)
rc.add_container(container_nginx)
rc.add_container(container_redis)
rc.set_replicas(3)
if utils.is_reachable(rc.config.api_host):
try:
rc.create()
vols = rc.model.model['spec']['volumes']
volnames = [x['name'] for x in vols]
self.assertIn(vol_name, volnames)
vols = rc.model.pod_spec.model['volumes']
volnames = [x['name'] for x in vols]
self.assertIn(vol_name, volnames)
self.assertEqual(1, len(rc.model.model['spec']['containers']))
mounts = rc.model.model['spec']['containers'][0]['volumeMounts']
mountnames = [x['name'] for x in mounts]
self.assertIn(vol_name, mountnames)
self.assertEqual(1, len(rc.model.pod_spec.model['containers']))
mounts = rc.model.pod_spec.model['containers'][0]['volumeMounts']
mountnames = [x['name'] for x in mounts]
self.assertIn(vol_name, mountnames)
except Exception as err:
self.assertIsInstance(err, TimedOutException)
def test_update_namespace_fails(self):
name = "yocontainer"
container = utils.create_container(name=name)
name = "yorc-{0}".format(str(uuid.uuid4()))
nspace = "yonamespace"
dep = utils.create_deployment(name=name)
dep.add_container(container)
if utils.is_reachable(dep.config.api_host):
dep.create()
dep.set_namespace(nspace)
with self.assertRaises(BadRequestException):
dep.update()
def test_update_namespace_fails(self):
name = "yocontainer"
container = utils.create_container(name=name)
name = "yorc-{0}".format(str(uuid.uuid4()))
nspace = "yonamespace"
dep = utils.create_deployment(name=name)
dep.add_container(container)
if utils.is_reachable(dep.config.api_host):
dep.create()
dep.namespace = nspace
with self.assertRaises(BadRequestException):
dep.update()
def test_update_name_fails(self):
name = "yocontainer"
container = utils.create_container(name=name)
name1 = "yodep1"
name2 = "yodep2"
dep = utils.create_deployment(name=name1)
dep.add_container(container)
if utils.is_reachable(dep.config.api_host):
dep.create()
dep.name = name2
with self.assertRaises(NotFoundException):
dep.update()
def test_create_already_exists(self):
name = "yodep-{0}".format(str(uuid.uuid4()))
dep = utils.create_deployment(name=name)
cont_name = "nginx"
cont_image = "nginx:1.7.9"
cont = utils.create_container(name=cont_name, image=cont_image)
dep.add_container(container=cont)
dep.desired_replicas = 1
if utils.is_reachable(dep.config.api_host):
dep.create()
with self.assertRaises(AlreadyExistsException):
dep.create()
def test_delete(self):
name = "yocontainer"
container = utils.create_container(name=name)
name = "yodep-{0}".format(str(uuid.uuid4()))
dep = utils.create_deployment(name=name)
dep.add_container(container)
if utils.is_reachable(dep.config.api_host):
dep.create()
utils.cleanup_deployments()
result = dep.list()
self.assertIsInstance(result, list)
self.assertEqual(0, len(result))
def test_delete(self):
name = "yocontainer"
container = utils.create_container(name=name)
name = "yodep-{0}".format(str(uuid.uuid4()))
dep = utils.create_deployment(name=name)
dep.add_container(container)
if utils.is_reachable(dep.config.api_host):
dep.create()
utils.cleanup_deployments()
result = dep.list()
self.assertIsInstance(result, list)
self.assertEqual(0, len(result))
def test_create_already_exists(self):
name = "yodep-{0}".format(str(uuid.uuid4()))
dep = utils.create_deployment(name=name)
cont_name = "nginx"
cont_image = "nginx:1.7.9"
cont = utils.create_container(name=cont_name, image=cont_image)
dep.add_container(container=cont)
dep.set_replicas(1)
if utils.is_reachable(dep.config.api_host):
dep.create()
with self.assertRaises(AlreadyExistsException):
dep.create()
def test_update_name_fails(self):
name = "yocontainer"
container = utils.create_container(name=name)
name1 = "yodep1"
name2 = "yodep2"
dep = utils.create_deployment(name=name1)
dep.add_container(container)
if utils.is_reachable(dep.config.api_host):
dep.create()
dep.name = name2
with self.assertRaises(BadRequestException):
dep.update()
def test_get_by_name(self):
cont_name = "yocontainer"
container = utils.create_container(name=cont_name)
name = "yodep-{0}".format(str(uuid.uuid4()))
dep = utils.create_deployment(name=name)
dep.add_container(container)
if utils.is_reachable(dep.config.api_host):
dep.create()
result = K8sDeployment.get_by_name(config=dep.config, name=name)
self.assertIsInstance(result, list)
self.assertEqual(1, len(result))
self.assertIsInstance(result[0], K8sDeployment)
self.assertEqual(dep, result[0])
def test_get_by_name(self):
cont_name = "yocontainer"
container = utils.create_container(name=cont_name)
name = "yodep-{0}".format(str(uuid.uuid4()))
dep = utils.create_deployment(name=name)
dep.add_container(container)
if utils.is_reachable(dep.config.api_host):
dep.create()
result = K8sDeployment.get_by_name(config=dep.config, name=name)
self.assertIsInstance(result, list)
self.assertEqual(1, len(result))
self.assertIsInstance(result[0], K8sDeployment)
self.assertEqual(dep, result[0])
def test_rc_nfs(self):
container_name = "nginx"
container_image = "nginx:1.7.9"
container_nginx = utils.create_container(name=container_name, image=container_image)
container_name = "redis"
container_image = "redis:3.0.7"
container_redis = utils.create_container(name=container_name, image=container_image)
vol_name = "nfs"
vol_type = "nfs"
vol_mount = "/test-nfs"
server = "howard.mtl.mnubo.com"
path = "/fs1/test-nfs"
volume = utils.create_volume(name=vol_name, type=vol_type, mount_path=vol_mount)
volume.set_server(server)
volume.set_path(path)
container_nginx.add_volume_mount(volume)
container_redis.add_volume_mount(volume)
rc_name = "nginx-{0}".format(str(uuid.uuid4()))
rc = utils.create_rc(name=rc_name)
rc.add_volume(volume)
rc.add_container(container_nginx)
rc.add_container(container_redis)
rc.set_replicas(3)
if utils.is_reachable(rc.config.api_host):
try:
rc.create()
vols = rc.model.model['spec']['volumes']
volnames = [x['name'] for x in vols]
self.assertIn(vol_name, volnames)
vols = rc.model.pod_spec.model['volumes']
volnames = [x['name'] for x in vols]
self.assertIn(vol_name, volnames)
self.assertEqual(1, len(rc.model.model['spec']['containers']))
mounts = rc.model.model['spec']['containers'][0]['volumeMounts']
mountnames = [x['name'] for x in mounts]
self.assertIn(vol_name, mountnames)
self.assertEqual(1, len(rc.model.pod_spec.model['containers']))
mounts = rc.model.pod_spec.model['containers'][0]['volumeMounts']
mountnames = [x['name'] for x in mounts]
self.assertIn(vol_name, mountnames)
except Exception as err:
self.assertIsInstance(err, TimedOutException)
def test_rc_git_repo(self):
container_name = "nginx"
container_image = "nginx:1.7.9"
container_nginx = utils.create_container(name=container_name, image=container_image)
container_name = "redis"
container_image = "redis:3.0.7"
container_redis = utils.create_container(name=container_name, image=container_image)
vol_name = "git-repo"
vol_type = "gitRepo"
vol_mount = "/test-git-repo"
repo = "https://*****:*****@git-lab1.mtl.mnubo.com/ops/traffic-analyzer.git"
revision = "e42d3dca1541ba085f34ce282feda1109a707c7b"
volume = utils.create_volume(name=vol_name, type=vol_type, mount_path=vol_mount)
volume.set_git_repository(repo)
volume.set_git_revision(revision)
container_nginx.add_volume_mount(volume)
container_redis.add_volume_mount(volume)
rc_name = "nginx-{0}".format(str(uuid.uuid4()))
rc = utils.create_rc(name=rc_name)
rc.add_volume(volume)
rc.add_container(container_nginx)
rc.add_container(container_redis)
rc.set_replicas(3)
if utils.is_reachable(rc.config.api_host):
try:
rc.create()
vols = rc.model.model['spec']['volumes']
volnames = [x['name'] for x in vols]
self.assertIn(vol_name, volnames)
vols = rc.model.pod_spec.model['volumes']
volnames = [x['name'] for x in vols]
self.assertIn(vol_name, volnames)
self.assertEqual(1, len(rc.model.model['spec']['containers']))
mounts = rc.model.model['spec']['containers'][0]['volumeMounts']
mountnames = [x['name'] for x in mounts]
self.assertIn(vol_name, mountnames)
self.assertEqual(1, len(rc.model.pod_spec.model['containers']))
mounts = rc.model.pod_spec.model['containers'][0]['volumeMounts']
mountnames = [x['name'] for x in mounts]
self.assertIn(vol_name, mountnames)
except Exception as err:
self.assertIsInstance(err, TimedOutException)
def fetch_certificates(self) -> bool:
"""Fetch the certificate files from AWS S3 service."""
# First test to see if we have an internet connection
if not is_reachable("https://aws.amazon.com/", True):
return False
cert_file_list = ("cert.pem", "chain.pem", "fullchain.pem",
"privkey.pem")
self.cert_dir.mkdir(0o755, parents=True, exist_ok=True)
for cert_file in cert_file_list:
if not aws_s3_get(f"{self.server_name}/{cert_file}",
Path(f"{self.cert_dir}/{cert_file}")):
return False
return True
def test_rc_secret(self):
container_name = "nginx"
container_image = "nginx:1.7.9"
container_nginx = utils.create_container(name=container_name, image=container_image)
container_name = "redis"
container_image = "redis:3.0.7"
container_redis = utils.create_container(name=container_name, image=container_image)
secret_name = "yosecret"
secret = utils.create_secret(name=secret_name)
k = ".secret-file"
v = "dmFsdWUtMg0KDQo="
secret.set_data(k, v)
vol_name = "secret"
vol_type = "secret"
vol_mount = "/test-secret"
volume = utils.create_volume(name=vol_name, type=vol_type, mount_path=vol_mount)
volume.set_secret_name(secret)
container_nginx.add_volume_mount(volume)
container_redis.add_volume_mount(volume)
rc_name = "app"
rc = utils.create_rc(name=rc_name)
rc.add_volume(volume)
rc.add_container(container_nginx)
rc.add_container(container_redis)
rc.set_replicas(1)
if utils.is_reachable(rc.config.api_host):
secret.create()
rc.create()
vols = rc.model.model['spec']['template']['spec']['volumes']
volnames = [x['name'] for x in vols]
self.assertIn(vol_name, volnames)
vols = rc.model.pod_spec.model['volumes']
volnames = [x['name'] for x in vols]
self.assertIn(vol_name, volnames)
self.assertEqual(2, len(rc.model.model['spec']['template']['spec']['containers']))
mounts = rc.model.model['spec']['template']['spec']['containers'][0]['volumeMounts']
mountnames = [x['name'] for x in mounts]
self.assertIn(vol_name, mountnames)
self.assertEqual(2, len(rc.model.pod_spec.model['containers']))
mounts = rc.model.pod_spec.model['containers'][0]['volumeMounts']
mountnames = [x['name'] for x in mounts]
self.assertIn(vol_name, mountnames)
def test_update_pod_labels(self):
name = "nginx"
image = "nginx:1.7.9"
container = utils.create_container(name=name, image=image)
dep_name = "yodep-{0}".format(str(uuid.uuid4()))
dep = utils.create_deployment(name=dep_name)
dep.add_container(container)
dep.set_replicas(3)
if utils.is_reachable(dep.config.api_host):
dep.create()
labels = dep.get_pod_labels()
labels['newkey'] = 'newvalue'
dep.set_pod_labels(labels)
updated = dep.update()
self.assertEqual(labels, updated.get_pod_labels())
def test_update_pod_labels(self):
name = "nginx"
image = "nginx:1.7.9"
container = utils.create_container(name=name, image=image)
dep_name = "yodep-{0}".format(str(uuid.uuid4()))
dep = utils.create_deployment(name=dep_name)
dep.add_container(container)
dep.desired_replicas = 3
if utils.is_reachable(dep.config.api_host):
dep.create()
labels = dep.pod_labels
labels['newkey'] = 'newvalue'
dep.pod_labels = labels
updated = dep.update()
self.assertEqual(labels, updated.pod_labels)
def test_create_three_replicas(self):
name = "yodep-{0}".format(str(uuid.uuid4()))
dep = utils.create_deployment(name=name)
cont_name = "nginx"
cont_image = "nginx:1.7.9"
cont = utils.create_container(name=cont_name, image=cont_image)
dep.add_container(container=cont)
dep.set_replicas(3)
if utils.is_reachable(dep.config.api_host):
d = dep.create()
self.assertIsNotNone(d)
self.assertIsInstance(d, K8sDeployment)
self.assertEqual(d, dep)
self.assertEqual(3, d.model.model['status']['replicas'])
self.assertEqual(3, d.model.model['status']['availableReplicas'])
self.assertEqual(3, d.model.model['status']['updatedReplicas'])
def test_create_zero_replicas(self):
name = "yodep-{0}".format(str(uuid.uuid4()))
dep = utils.create_deployment(name=name)
cont_name = "redis"
cont_image = "redis:3.2.3"
cont = utils.create_container(name=cont_name, image=cont_image)
dep.add_container(container=cont)
if utils.is_reachable(dep.config.api_host):
d = dep.create()
self.assertIsNotNone(d)
self.assertIsInstance(d, K8sDeployment)
self.assertEqual(d, dep)
self.assertEqual(0, d.model.model['spec']['replicas'])
self.assertNotIn('replicas', d.model.model['status'])
self.assertNotIn('availableReplicas', d.model.model['status'])
self.assertNotIn('updatedReplicas', d.model.model['status'])
def test_scale(self):
cont_name = "yocontainer"
container = utils.create_container(name=cont_name)
name = "yodep-{0}".format(str(uuid.uuid4()))
dep = utils.create_deployment(name=name)
dep.add_container(container)
dep.set_replicas(3)
if utils.is_reachable(dep.config.api_host):
dep.create()
replicas = dep.get_replicas()
for k in replicas:
self.assertEqual(3, replicas[k])
dep.scale(5)
replicas = dep.get_replicas()
for k in replicas:
self.assertEqual(5, replicas[k])
def test_create_one_replica(self):
name = "yodep-{0}".format(str(uuid.uuid4()))
dep = utils.create_deployment(name=name)
cont_name = "nginx"
cont_image = "nginx:1.7.9"
cont = utils.create_container(name=cont_name, image=cont_image)
dep.add_container(container=cont)
dep.desired_replicas = 1
if utils.is_reachable(dep.config.api_host):
d = dep.create()
self.assertIsNotNone(d)
self.assertIsInstance(d, K8sDeployment)
self.assertEqual(d, dep)
self.assertEqual(1, d.desired_replicas)
self.assertEqual(1, d.available_replicas)
self.assertEqual(1, d.updated_replicas)
def test_scale(self):
cont_name = "yocontainer"
container = utils.create_container(name=cont_name)
name = "yodep-{0}".format(str(uuid.uuid4()))
dep = utils.create_deployment(name=name)
dep.add_container(container)
dep.desired_replicas = 3
if utils.is_reachable(dep.config.api_host):
dep.create()
self.assertEqual(3, dep.desired_replicas)
self.assertEqual(3, dep.updated_replicas)
self.assertEqual(3, dep.available_replicas)
dep.scale(5)
self.assertEqual(5, dep.desired_replicas)
self.assertEqual(5, dep.updated_replicas)
self.assertEqual(5, dep.available_replicas)
def wait_for_webserver(self) -> bool:
"""
Wait until Nginx webserver is up.
wait_for_webserver will wait until the Nginx webserver has started. This
is done by periodically sending an http request to our URL and waiting for
a response of 200 (OK) or 301 (Redirected). We do not allow redirects nor
do we send an https request because the webserver is started up with a
self-signed certificate which will cause an error in these cases.
"""
attempt_count = 0
while attempt_count < self.max_connect_tries:
if is_reachable(f"http://{self.server_name}", False):
return True
attempt_count += 1
time.sleep(10)
return False
def test_create_zero_replicas(self):
name = "yodep-{0}".format(str(uuid.uuid4()))
dep = utils.create_deployment(name=name)
cont_name = "redis"
cont_image = "redis:3.2.3"
cont = utils.create_container(name=cont_name, image=cont_image)
dep.add_container(container=cont)
if utils.is_reachable(dep.config.api_host):
d = dep.create()
self.assertIsNotNone(d)
self.assertIsInstance(d, K8sDeployment)
self.assertEqual(d, dep)
self.assertEqual(0, d.desired_replicas)
self.assertIsNone(d.available_replicas)
self.assertIsNone(d.current_replicas)
self.assertIsNone(d.unavailable_replicas)
self.assertIsNone(d.updated_replicas)
def test_update_container_image(self):
name = "nginx"
image1 = "nginx:1.7.9"
image2 = "nginx:1.9.1"
container = utils.create_container(name=name, image=image1)
dep_name = "yodep-{0}".format(str(uuid.uuid4()))
dep = utils.create_deployment(name=dep_name)
dep.add_container(container)
dep.set_replicas(3)
if utils.is_reachable(dep.config.api_host):
dep.create()
self.assertEqual(image1, dep.model.model['spec']['template']['spec']['containers'][0]['image'])
dep.set_container_image(name=name, image=image2)
dep.update()
self.assertIn('annotations', dep.model.deployment_metadata.model)
self.assertIn('deployment.kubernetes.io/revision', dep.model.deployment_metadata.model['annotations'])
self.assertNotEqual(image1, dep.model.model['spec']['template']['spec']['containers'][0]['image'])
self.assertEqual(image2, dep.model.model['spec']['template']['spec']['containers'][0]['image'])
def test_cassandra_setup(self):
svc = Service(utils.cassandra_service())
k8s_service = utils.create_service(name="cassandra")
k8s_service.model = svc
rc = ReplicationController(utils.cassandra_rc())
k8s_rc = utils.create_rc(name="cassandra")
k8s_rc.model = rc
ds = DaemonSet(utils.cassandra_daemonset())
k8s_ds = utils.create_daemonset(name="cassandra")
k8s_ds.model = ds
if utils.is_reachable(k8s_rc.config.api_host):
k8s_service.create()
k8s_rc.create()
self.assertIsInstance(k8s_service, K8sService)
self.assertIsInstance(k8s_rc, K8sReplicationController)
def test_rc_hostpath(self):
container_name = "nginx"
container_image = "nginx:1.7.9"
container_nginx = utils.create_container(name=container_name, image=container_image)
container_name = "redis"
container_image = "redis:3.0.7"
container_redis = utils.create_container(name=container_name, image=container_image)
vol_name = "hostpath"
vol_type = "hostPath"
vol_mount = "/test-hostpath"
hostpath = "/var/lib/docker"
volume = utils.create_volume(name=vol_name, type=vol_type, mount_path=vol_mount)
volume.set_path(hostpath)
container_nginx.add_volume_mount(volume)
container_redis.add_volume_mount(volume)
rc_name = "app"
rc = utils.create_rc(name=rc_name)
rc.add_volume(volume)
rc.add_container(container_nginx)
rc.add_container(container_redis)
rc.set_replicas(1)
if utils.is_reachable(rc.config.api_host):
rc.create()
vols = rc.model.model['spec']['template']['spec']['volumes']
volnames = [x['name'] for x in vols]
self.assertIn(vol_name, volnames)
vols = rc.model.pod_spec.model['volumes']
volnames = [x['name'] for x in vols]
self.assertIn(vol_name, volnames)
self.assertEqual(2, len(rc.model.model['spec']['template']['spec']['containers']))
mounts = rc.model.model['spec']['template']['spec']['containers'][0]['volumeMounts']
mountnames = [x['name'] for x in mounts]
self.assertIn(vol_name, mountnames)
self.assertEqual(2, len(rc.model.pod_spec.model['containers']))
mounts = rc.model.pod_spec.model['containers'][0]['volumeMounts']
mountnames = [x['name'] for x in mounts]
self.assertIn(vol_name, mountnames)
def test_list_multiple(self):
name = "yocontainer"
container = utils.create_container(name=name)
config = K8sConfig(kubeconfig=utils.kubeconfig_fallback)
deployments = []
count = 3
objs = []
if utils.is_reachable(config.api_host):
for i in range(0, count):
name = "yodep-{0}".format(str(uuid.uuid4()))
dep = utils.create_deployment(config, name)
dep.add_container(container)
result = dep.create()
self.assertIsInstance(result, K8sDeployment)
self.assertEqual(dep, result)
deployments.append(dep)
objs = dep.list()
self.assertEqual(count, len(deployments))
self.assertEqual(count, len(objs))
def test_pod_secret(self):
container_name = "nginx"
container_image = "nginx:1.7.9"
container = utils.create_container(name=container_name, image=container_image)
secret_name = "yosecret"
secret = utils.create_secret(name=secret_name)
k = ".secret-file"
v = "dmFsdWUtMg0KDQo="
secret.set_data(k, v)
vol_name = "secret"
vol_type = "secret"
vol_mount = "/test-secret"
volume = utils.create_volume(name=vol_name, type=vol_type, mount_path=vol_mount)
volume.set_secret_name(secret)
container.add_volume_mount(volume)
pod_name = "nginx"
pod = utils.create_pod(name=pod_name)
pod.add_volume(volume)
pod.add_container(container)
if utils.is_reachable(pod.config.api_host):
secret.create()
pod.create()
vols = pod.model.model['spec']['volumes']
volnames = [x['name'] for x in vols]
self.assertIn(vol_name, volnames)
vols = pod.model.pod_spec.model['volumes']
volnames = [x['name'] for x in vols]
self.assertIn(vol_name, volnames)
self.assertEqual(1, len(pod.model.model['spec']['containers']))
mounts = pod.model.model['spec']['containers'][0]['volumeMounts']
mountnames = [x['name'] for x in mounts]
self.assertIn(vol_name, mountnames)
self.assertEqual(1, len(pod.model.pod_spec.model['containers']))
mounts = pod.model.pod_spec.model['containers'][0]['volumeMounts']
mountnames = [x['name'] for x in mounts]
self.assertIn(vol_name, mountnames)
def test_add_image_pull_secret(self):
name = "mnubo.com-sa-{0}".format(str(uuid.uuid4().get_hex()[:5]))
acct = utils.create_service_account(name=name)
data = {
"auths": {
"repo:port": {
"auth": "authstring",
"email": "*****@*****.**"
}
}
}
if utils.is_reachable(acct.config.api_host):
acct.create()
secret = K8sSecret.create_image_pull_secret(config=acct.config,
name=acct.name,
data=data)
acct.add_image_pull_secret(secret)
secrets = K8sSecret.list_image_pull_secrets()
self.assertEqual(1, len(secrets))
def test_list_multiple(self):
name = "yocontainer"
container = utils.create_container(name=name)
config = K8sConfig(kubeconfig=utils.kubeconfig_fallback)
deployments = []
count = 3
objs = []
if utils.is_reachable(config.api_host):
for i in range(0, count):
name = "yodep-{0}".format(str(uuid.uuid4()))
dep = utils.create_deployment(config, name)
dep.add_container(container)
result = dep.create()
self.assertIsInstance(result, K8sDeployment)
self.assertEqual(dep, result)
deployments.append(dep)
objs = dep.list()
self.assertEqual(count, len(deployments))
self.assertEqual(count, len(objs))
def test_gce_pd(self):
json = {
"kind": "StorageClass",
"apiVersion": "storage.k8s.io/v1beta1",
"metadata": {
"name": "slow"
},
"provisioner": "kubernetes.io/gce-pd",
"parameters": {
"type": "pd-standard",
}
}
sc = StorageClass(json)
k8s_sc = utils.create_storage_class(name='sc')
k8s_sc.model = sc
if utils.is_reachable(k8s_sc.config.api_host):
k8s_sc.create()
from_get = k8s_sc.get()
self.assertIsInstance(from_get, K8sStorageClass)
def test_create_no_args(self):
name = "yodep-{0}".format(str(uuid.uuid4()))
dep = utils.create_deployment(name=name)
if utils.is_reachable(dep.config.api_host):
with self.assertRaises(UnprocessableEntityException):
dep.create()
def test_delete_nonexistent(self):
name = "yorc-{0}".format(str(uuid.uuid4()))
dep = utils.create_deployment(name=name)
if utils.is_reachable(dep.config.api_host):
with self.assertRaises(NotFoundException):
dep.delete()
def test_delete_nonexistent(self):
name = "yorc-{0}".format(str(uuid.uuid4()))
dep = utils.create_deployment(name=name)
if utils.is_reachable(dep.config.api_host):
with self.assertRaises(NotFoundException):
dep.delete()
def test_create_no_args(self):
name = "yodep-{0}".format(str(uuid.uuid4()))
dep = utils.create_deployment(name=name)
if utils.is_reachable(dep.config.api_host):
with self.assertRaises(UnprocessableEntityException):
dep.create()