def _run_dsl(args):
os: MockOsSystem = args["os_system"]
fs: MockFileSystem = args["file_system"]
project_id = "project1"
app_name = 'test-service'
cluster_name = 'prod-us-east1'
kubectl_version = "v1.15.3"
service_account_b64 = b64encode(json.dumps({'key': 'someKey'}).encode('utf-8'))
container_1 = container(name='myservice', image='busybox:1.0')
container_2 = container(name='myservice-2', image='busybox:2.0')
os.mock_clusters_list([cluster_name])
os.mock_kubernetes_release(E.success(kubectl_version))
os.mock_download_install_kubectl(kubectl_version, E.success())
os.mock_create_kube_config(cluster_name, E.success())
os.mock_kubectl_apply_temp_file(cluster_name, E.success())
_, result = run_in_cluster(
conn=gke_conn(cluster_name, project_id, service_account_b64),
templates=[
deployment(app_name)
.with_containers([container_1, container_2])
]
)
deployment_yaml = find_write_template_calls(fs)[0]
containers = deployment_yaml['spec']['template']['spec']['containers']
assert containers[0]['name'] == 'myservice-app'
assert containers[0]['image'] == 'busybox:1.0'
assert containers[1]['name'] == 'myservice-2-app'
assert containers[1]['image'] == 'busybox:2.0'
def _run_dsl(args):
os: MockOsSystem = args["os_system"]
fs: MockFileSystem = args["file_system"]
project_id = "project1"
app_name = 'test-service'
cluster_name = 'prod-us-east1'
kubectl_version = "v1.15.3"
service_account_b64 = b64encode(json.dumps({'key': 'someKey'}).encode('utf-8'))
os.mock_clusters_list([cluster_name])
os.mock_kubernetes_release(E.success(kubectl_version))
os.mock_download_install_kubectl(kubectl_version, E.success())
os.mock_create_kube_config(cluster_name, E.success())
os.mock_kubectl_apply_temp_file(cluster_name, E.success())
_, result = run_in_cluster(
conn=gke_conn(cluster_name, project_id, service_account_b64),
templates=[
deployment(app_name)
.with_rolling_update(max_surge='20%', max_unavailable='20%')
.with_volume_claim(name='test-volume', claim_name='some-claim-name')
.with_container(container('test', 'test:100')
.with_volume_mount('test-volume', '/var/data/my-data')
.with_environment_from_context('ENV', lambda c: c('cluster_name')))
]
)
deployment_yaml = find_write_template_calls(fs)[0]
assert deployment_yaml['spec']['template']['spec']['containers'][0]['env'][1]['name'] == 'ENV'
assert deployment_yaml['spec']['template']['spec']['containers'][0]['env'][1]['value'] == cluster_name
def _run_dsl(args):
fs: MockFileSystem = args['file_system']
cluster_name = 'prod-us-east1'
project_id = 'project1'
service_account_b64 = b64encode(
json.dumps({
'key': 'someKey'
}).encode('utf-8'))
_, result = run_in_cluster(
conn=gke_conn(cluster_name, project_id, service_account_b64),
templates=[
micro_service(
'test', "test-service:1.0.0", 3000).with_rolling_update(
max_surge='20%',
max_unavailable='20%').with_empty_volume(
'my-volume', '/var/data/my-data').with_sidecar(
container(
'my-sidecar',
'my-sidecar:1.0.0').with_volume_mount(
'my-volume', 'var/data/sidecar-data'))
])
deployment = find_write_template_calls(fs)[1]
assert deployment['spec']['strategy'] == {
'rollingUpdate': {
'maxSurge': '20%',
'maxUnavailable': '20%'
},
'type': 'RollingUpdate'
}
def _run_dsl(args):
os: MockOsSystem = args["os_system"]
project_id = "project1"
cluster_name = 'prod-us-east1'
kubectl_version = "v1.15.3"
service_account_b64 = b64encode(
json.dumps({
'key': 'someKey'
}).encode('utf-8'))
os.mock_clusters_list([cluster_name])
os.mock_kubernetes_release(E.success(kubectl_version))
os.mock_download_install_kubectl(kubectl_version, E.success())
os.mock_create_kube_config(cluster_name, E.success())
os.mock_kubectl(cluster_name, 'get mappings',
E.failure('No such resource'))
os.mock_kubectl(cluster_name, 'get virtualservices',
E.failure('No such resource'))
with patch.object(sys, "exit") as mock_exit:
_, error = run_in_cluster(conn=gke_conn(cluster_name, project_id,
service_account_b64),
templates=[
gateway_mapping(
'api', 'api.com',
'api.default.svc.cluster.local')
])
assert mock_exit.call_args[0][0] == 1
assert str(error.caught_error) == 'Unsupported gateway'
def _run_dsl(args):
fs: MockFileSystem = args['file_system']
cluster_name = 'prod-us-east1'
project_id = 'project1'
service_account_b64 = b64encode(
json.dumps({
'key': 'someKey'
}).encode('utf-8'))
_, result = run_in_cluster(
conn=gke_conn(cluster_name, project_id, service_account_b64),
templates=[
micro_service(
'test', "test-service:1.0.0",
3000).with_ensure_only_one().with_empty_volume(
'my-volume', '/var/data/my-data').with_sidecar(
container('my-sidecar',
'my-sidecar:1.0.0').with_volume_mount(
'my-volume',
'var/data/sidecar-data'))
])
deployment = find_write_template_calls(fs)[1]
assert deployment['spec']['replicas'] == 1
assert deployment['spec']['strategy'] == {'type': 'Recreate'}
hpa = find_write_template_calls(fs)[2]
assert hpa['spec']['minReplicas'] == 1
assert hpa['spec']['maxReplicas'] == 1
def _run_dsl(args):
fs: MockFileSystem = args['file_system']
cluster_name = 'prod-us-east1'
project_id = 'project1'
service_account_b64 = b64encode(
json.dumps({
'key': 'someKey'
}).encode('utf-8'))
_, result = run_in_cluster(
conn=gke_conn(cluster_name, project_id, service_account_b64),
templates=[
micro_service(
'test', "test-service:1.0.0", 3000).with_replicas(
min=5, max=10,
cpu_threshold_percentage=80).with_empty_volume(
'my-volume', '/var/data/my-data').with_sidecar(
container(
'my-sidecar',
'my-sidecar:1.0.0').with_volume_mount(
'my-volume', 'var/data/sidecar-data'))
])
deployment = find_write_template_calls(fs)[1]
assert deployment['spec']['replicas'] == 5
hpa = find_write_template_calls(fs)[2]
assert hpa['spec']['minReplicas'] == 5
assert hpa['spec']['maxReplicas'] == 10
assert hpa['spec']['targetCPUUtilizationPercentage'] == 80
def _run_dsl(args):
fs: MockFileSystem = args['file_system']
os: MockOsSystem = args["os_system"]
os.mock_clusters_list([
'prod-us-east1-api-cluster', 'prod-10-api-cluster',
'stage-10-api-cluster'
])
cluster_name = 'prod-.*-api-cluster'
project_id = 'project1'
service_account_b64 = b64encode(
json.dumps({
'key': 'someKey'
}).encode('utf-8'))
_, result = run_in_cluster(
conn=gke_conn(cluster_name, project_id, service_account_b64),
templates=[
micro_service(
'test', "test-service:1.0.0", 3000).with_empty_volume(
'my-volume', '/var/data/my-data').with_sidecar(
container('my-sidecar',
'my-sidecar:1.0.0').with_volume_mount(
'my-volume',
'var/data/sidecar-data'))
])
assert 'prod-us-east1-api-cluster' in find_cluster_templates(fs)
assert 'prod-10-api-cluster' in find_cluster_templates(fs)
assert 'stage-10-api-cluster' not in find_cluster_templates(fs)
def _run_dsl(args):
fs: MockFileSystem = args["file_system"]
cluster_name = 'prod-us-east1'
project_id = 'project1'
service_account_b64 = b64encode(
json.dumps({
'key': 'someKey'
}).encode('utf-8'))
_, result = run_in_cluster(
conn=gke_conn(cluster_name, project_id, service_account_b64),
templates=[
micro_service(
'test', "test-service:1.0.0", 3000).with_empty_volume(
'my-volume', '/var/data/my-data').with_sidecar(
container('my-sidecar',
'my-sidecar:1.0.0').with_volume_mount(
'my-volume',
'var/data/sidecar-data'))
])
deployment = find_write_template_calls(fs)[1]
assert deployment['spec']['template']['spec']['volumes'][0] == {
'name': 'my-volume',
'emptyDir': {}
}
microservice = deployment['spec']['template']['spec']['containers'][0]
assert microservice['volumeMounts'][0] == {
'name': 'my-volume',
'mountPath': '/var/data/my-data'
}
sidecar = deployment['spec']['template']['spec']['containers'][1]
assert sidecar['volumeMounts'][0] == {
'name': 'my-volume',
'mountPath': 'var/data/sidecar-data'
}
def _run_dsl(args):
os: MockOsSystem = args["os_system"]
fs: MockFileSystem = args["file_system"]
project_id = "project1"
app_name = 'test-service'
cluster_name = 'prod-us-east1'
kubectl_version = "v1.15.3"
service_account_b64 = b64encode(json.dumps({'key': 'someKey'}).encode('utf-8'))
os.mock_clusters_list([cluster_name])
os.mock_kubernetes_release(E.success(kubectl_version))
os.mock_download_install_kubectl(kubectl_version, E.success())
os.mock_create_kube_config(cluster_name, E.success())
os.mock_kubectl_apply_temp_file(cluster_name, E.success())
_, result = run_in_cluster(
conn=gke_conn(cluster_name, project_id, service_account_b64),
templates=[
deployment(app_name)
.with_rolling_update(max_surge='20%', max_unavailable='20%')
.with_empty_volume(name='test-volume')
.with_container(container('test', 'test:100'))
.with_container(container('test-2', 'test-2:100'))
]
)
deployment_yaml = find_write_template_calls(fs)[0]
assert deployment_yaml['spec']['strategy'] == {'rollingUpdate': {'maxSurge': '20%', 'maxUnavailable': '20%'},
'type': 'RollingUpdate'}
def _run_dsl(args):
fs: MockFileSystem = args['file_system']
os: MockOsSystem = args["os_system"]
project_id = "project1"
job_name = 'test-service'
cluster_name = 'prod-us-east1'
kubectl_version = "v1.15.3"
image_url = "test-service:1.0.0"
service_account_b64 = b64encode(
json.dumps({
'key': 'someKey'
}).encode('utf-8'))
os.mock_clusters_list([cluster_name])
os.mock_kubernetes_release(E.success(kubectl_version))
os.mock_download_install_kubectl(kubectl_version, E.success())
os.mock_create_kube_config(cluster_name, E.success())
os.mock_kubectl_apply_temp_file(cluster_name, E.success())
_, result = run_in_cluster(
conn=gke_conn(cluster_name, project_id, service_account_b64),
templates=[
cron_job(job_name, image_url).with_environment_secret(
'coolSecret', {'ENV_NAME': 'secretkey'})
])
yamls = find_write_template_calls(fs)
container = yamls[0]['spec']['jobTemplate']['spec']['template'][
'spec']['containers'][0]
assert container['env'][0]['name'] == 'ENV_NAME'
assert container['env'][0]['valueFrom']['secretKeyRef'][
'name'] == 'coolSecret'
assert container['env'][0]['valueFrom']['secretKeyRef'][
'key'] == 'secretkey'
def _run_dsl(args):
fs: MockFileSystem = args['file_system']
cluster_name = 'prod-us-east1'
project_id = 'project1'
service_account_b64 = b64encode(
json.dumps({
'key': 'someKey'
}).encode('utf-8'))
_, result = run_in_cluster(
conn=gke_conn(cluster_name, project_id, service_account_b64),
templates=[
micro_service(
'test', "test-service:1.0.0", 3000).with_annotations({
'some':
'thing'
}).with_empty_volume(
'my-volume', '/var/data/my-data').with_sidecar(
container('my-sidecar',
'my-sidecar:1.0.0').with_volume_mount(
'my-volume',
'var/data/sidecar-data'))
])
deployment = find_write_template_calls(fs)[1]
assert deployment['spec']['template']['metadata']['annotations'] == {
'some': 'thing'
}
def _run_dsl(args):
fs: MockFileSystem = args['file_system']
os: MockOsSystem = args["os_system"]
project_id = "project1"
secret_name = 'test-secret'
cluster_name = 'prod-us-east1'
kubectl_version = "v1.15.3"
service_account_b64 = b64encode(json.dumps({'key': 'someKey'}).encode('utf-8'))
os.mock_clusters_list([cluster_name])
os.mock_kubernetes_release(E.success(kubectl_version))
os.mock_download_install_kubectl(kubectl_version, E.success())
os.mock_create_kube_config(cluster_name, E.success())
os.mock_kubectl_apply_temp_file(cluster_name, E.success())
_, result = run_in_cluster(
conn=gke_conn(cluster_name, project_id, service_account_b64),
templates=[
secret(secret_name, data={'key1': 'someValue'})
]
)
yamls = find_write_template_calls(fs)
assert yamls[0]['kind'] == 'Secret'
assert yamls[0]['metadata']['name'] == secret_name
assert b64decode(yamls[0]['data']['key1'].encode('utf-8')).decode('utf-8') == 'someValue'
def _run_dsl(args):
os: MockOsSystem = args["os_system"]
fs: MockFileSystem = args["file_system"]
project_id = "project1"
service_name = 'test-service'
cluster_name = 'prod-us-east1'
kubectl_version = "v1.15.3"
image_url = "test-service:1.0.0"
app_port = 3000
service_port = 80
service_account_b64 = b64encode(
json.dumps({
'key': 'someKey'
}).encode('utf-8'))
os.mock_clusters_list([cluster_name])
os.mock_kubernetes_release(E.success(kubectl_version))
os.mock_download_install_kubectl(kubectl_version, E.success())
os.mock_create_kube_config(cluster_name, E.success())
os.mock_kubectl_apply_temp_file(cluster_name, E.success())
_, result = run_in_cluster(
conn=gke_conn(cluster_name, project_id, service_account_b64),
templates=[micro_service(service_name, image_url, app_port)])
yamls = find_write_template_calls(fs)
assert yamls[0]['kind'] == 'Service'
assert yamls[0]['metadata']['name'] == service_name
assert yamls[0]['spec']['selector']['app'] == service_name + '-app'
assert yamls[0]['spec']['ports'][0]['targetPort'] == app_port
assert yamls[0]['spec']['ports'][0]['port'] == service_port
assert yamls[1]['kind'] == 'Deployment'
def _run_dsl(args):
fs: MockFileSystem = args["file_system"]
service_type = 'NodePort'
cluster_name = 'prod-us-east1'
project_id = 'project1'
service_account_b64 = b64encode(
json.dumps({
'key': 'someKey'
}).encode('utf-8'))
_, result = run_in_cluster(
conn=gke_conn(cluster_name, project_id, service_account_b64),
templates=[
micro_service(
'test', "test-service:1.0.0",
3000).with_service_type(service_type).with_resources(
cpu_request="1",
memory_request="64Mi",
cpu_limit="2",
memory_limit="128Mi")
])
yamls = find_write_template_calls(fs)
assert yamls[1]['kind'] == 'Deployment'
container = yamls[1]['spec']['template']['spec']['containers'][0]
assert container['resources'] == {
'requests': {
'cpu': '1',
'memory': '64Mi'
},
'limits': {
'cpu': '2',
'memory': '128Mi'
}
}
def _run_dsl(args):
os: MockOsSystem = args["os_system"]
fs: MockFileSystem = args['file_system']
project_id = "project1"
job_name = 'test-service'
cluster_name = 'prod-us-east1'
kubectl_version = "v1.15.3"
image_url = "test-service:1.0.0"
service_account_b64 = b64encode(
json.dumps({
'key': 'someKey'
}).encode('utf-8'))
os.mock_clusters_list([cluster_name])
os.mock_kubernetes_release(E.success(kubectl_version))
os.mock_download_install_kubectl(kubectl_version, E.success())
os.mock_create_kube_config(cluster_name, E.success())
os.mock_kubectl_apply_temp_file(cluster_name, E.success())
_, result = run_in_cluster(conn=gke_conn(cluster_name, project_id,
service_account_b64),
templates=[cron_job(job_name, image_url)])
yamls = find_write_template_calls(fs)
assert yamls[0]['kind'] == 'CronJob'
assert yamls[0]['metadata']['name'] == job_name
container = yamls[0]['spec']['jobTemplate']['spec']['template'][
'spec']['containers'][0]
assert container['name'] == job_name
assert container['image'] == image_url
def _run_dsl(_args):
project_id = "someId"
service_account_key = {"key": "someKey"}
service_account_b64 = b64encode(
json.dumps(service_account_key).encode('utf-8')).decode('utf-8')
conf = config()
k_ctl = gke_conn(cluster_regex='.*',
project_id=project_id,
service_account_b64=service_account_b64)(conf)
provider: GKEProvider = k_ctl.get_provider()
assert provider.get_project_id() == project_id
def _run_dsl(_args):
project_id = "someProjectId"
conf = config()
with patch('sys.exit',
return_value=b64encode('{"error": "RaisedError"}'.encode(
'utf-8')).decode('utf-8')):
k_ctl = gke_conn(cluster_regex='.*', project_id=project_id)(conf)
provider: GKEProvider = k_ctl.get_provider()
assert provider.get_service_account_info(
)['error'] == 'RaisedError'
def _run_dsl(_args):
project_id = None
service_account_key = {"key": "someKey"}
service_account_b64 = b64encode(
json.dumps(service_account_key).encode('utf-8')).decode('utf-8')
conf = config()
with patch('sys.exit', return_value="RaisedError"):
k_ctl = gke_conn(cluster_regex='.*',
project_id=project_id,
service_account_b64=service_account_b64)(conf)
provider: GKEProvider = k_ctl.get_provider()
assert provider.get_project_id() == "RaisedError"
def _run_dsl(args):
mock_fs: MockFileSystem = args['file_system']
project_id = "project1"
service_account_b64 = b64encode(json.dumps({'key': 'someKey'}).encode('utf-8'))
cluster_name = 'prod-us-east1'
_, result = run_in_cluster(
conn=gke_conn(cluster_name, project_id, service_account_b64),
templates=[
from_dicts([{"kind": "Service"}])
]
)
yamls = find_write_template_calls(mock_fs)
assert yamls[0]['kind'] == 'Service'
def _run_dsl(args):
fs: MockFileSystem = args['file_system']
_, result = run_in_cluster(
conn=gke_conn(cluster_name, project_id, service_account_b64),
templates=[
micro_service('test', "test-service:1.0.0",
3000).with_init_containers(
[init_container_1, init_container_2])
])
deployment = find_write_template_calls(fs)[1]
init_containers = deployment['spec']['template']['spec'][
'initContainers']
assert init_containers[0]['name'] == 'init-myservice'
assert init_containers[0]['image'] == 'busybox:1.0'
assert init_containers[1]['name'] == 'init-myservice-2'
assert init_containers[1]['image'] == 'busybox:2.0'
def _run_dsl(args):
os: MockOsSystem = args['os_system']
project_id = "someId"
os.mock_get_env('KG_PROJECT_ID', return_values=[project_id])
os.mock_get_env('KG_DELETE', return_values=["true"])
os.mock_get_env('KG_TEMPLATE', return_values=["false"])
service_account_key = {'key': 'someKey'}
service_account_b64 = b64encode(
json.dumps(service_account_key).encode('utf-8')).decode('utf-8')
conf = config()
k_ctl = gke_conn(cluster_regex='.*',
project_id=project_id,
service_account_b64=service_account_b64)(conf)
provider: GKEProvider = k_ctl.get_provider()
assert provider.get_project_id() == project_id
def _run_dsl(args):
os: MockOsSystem = args["os_system"]
fs: MockFileSystem = args['file_system']
project_id = "project1"
cluster_name = 'prod-us-east1'
kubectl_version = "v1.15.3"
service_account_b64 = b64encode(
json.dumps({
'key': 'someKey'
}).encode('utf-8'))
os.mock_clusters_list([cluster_name])
os.mock_kubernetes_release(E.success(kubectl_version))
os.mock_download_install_kubectl(kubectl_version, E.success())
os.mock_create_kube_config(cluster_name, E.success())
os.mock_kubectl(cluster_name, 'get mappings',
E.failure('No such resource'))
os.mock_kubectl(cluster_name, 'get virtualservices', E.success())
_, result = run_in_cluster(conn=gke_conn(cluster_name, project_id,
service_account_b64),
templates=[
gateway_mapping(
'api', 'api.com',
'api.default.svc.cluster.local')
])
yamls = find_write_template_calls(fs)
output_yaml = yamls[0]
assert output_yaml == {
'apiVersion': 'networking.istio.io/v1alpha3',
'kind': 'VirtualService',
'metadata': {
'name': 'api-vs'
},
'spec': {
'hosts': ['api.com'],
'gateways': ['cluster-gateway'],
'http': [{
'route': [{
'destination': {
'host': 'api.default.svc.cluster.local'
}
}]
}]
}
}
def _run_dsl(args):
os: MockOsSystem = args['os_system']
project_id = "someId"
service_account_key = {"key": "someKey"}
service_account_b64 = b64encode(
json.dumps(service_account_key).encode('utf-8')).decode('utf-8')
os.mock_get_env('KG_SERVICE_ACCOUNT_B64',
return_values=[service_account_b64])
os.mock_get_env('KG_DELETE', return_values=["true"])
os.mock_get_env('KG_TEMPLATE', return_values=["false"])
conf = config()
k_ctl = gke_conn(cluster_regex='.*', project_id=project_id)(conf)
provider: GKEProvider = k_ctl.get_provider()
assert_same_dict(provider.get_service_account_info(),
service_account_key)
def _run_dsl(args):
fs: MockFileSystem = args["file_system"]
service_type = 'NodePort'
cluster_name = 'prod-us-east1'
project_id = 'project1'
service_account_b64 = b64encode(
json.dumps({
'key': 'someKey'
}).encode('utf-8'))
_, result = run_in_cluster(
conn=gke_conn(cluster_name, project_id, service_account_b64),
templates=[
micro_service('test', "test-service:1.0.0",
3000).with_service_type(service_type)
])
yamls = find_write_template_calls(fs)
assert yamls[0]['kind'] == 'Service'
assert yamls[0]['spec']['type'] == 'NodePort'
def _run_dsl(args):
mock_fs: MockFileSystem = args['file_system']
project_id = "project1"
cluster_name = 'prod-us-east1'
service_account_b64 = b64encode(
json.dumps({
'key': 'someKey'
}).encode('utf-8'))
service_defaults_path = '{}/service_defaults.yaml'.format(
fs.dirname(__file__))
PyMock.mock(mock_fs.get_mock().read,
call_fake=lambda path: read(path['args'][0])
if path['args'][0] == service_defaults_path else '')
_, result = run_in_cluster(
conn=gke_conn(cluster_name, project_id, service_account_b64),
templates=[from_file(service_defaults_path)])
yamls = find_write_template_calls(mock_fs)
assert yamls[0]['kind'] == 'Service'
def _run_dsl(args):
fs: MockFileSystem = args["file_system"]
cluster_name = 'prod-us-east1'
project_id = 'project1'
service_account_b64 = b64encode(
json.dumps({
'key': 'someKey'
}).encode('utf-8'))
_, result = run_in_cluster(
conn=gke_conn(cluster_name, project_id, service_account_b64),
templates=[
micro_service('test', "test-service:1.0.0", 3000).with_sidecar(
container('my-sidecar', 'my-sidecar:1.0.0'))
])
yamls = find_write_template_calls(fs)
assert yamls[1]['kind'] == 'Deployment'
sidecar = yamls[1]['spec']['template']['spec']['containers'][1]
assert sidecar['name'] == 'my-sidecar-app'
assert sidecar['image'] == 'my-sidecar:1.0.0'
def _run_dsl(args):
os: MockOsSystem = args["os_system"]
fs: MockFileSystem = args['file_system']
project_id = "project1"
claim_name = 'test-volume'
cluster_name = 'prod-us-east1'
kubectl_version = "v1.15.3"
service_account_b64 = b64encode(
json.dumps({
'key': 'someKey'
}).encode('utf-8'))
os.mock_clusters_list([cluster_name])
os.mock_kubernetes_release(E.success(kubectl_version))
os.mock_download_install_kubectl(kubectl_version, E.success())
os.mock_create_kube_config(cluster_name, E.success())
os.mock_kubectl_apply_temp_file(cluster_name, E.success())
_, result = run_in_cluster(
conn=gke_conn(cluster_name, project_id, service_account_b64),
templates=[volume_claim(claim_name).with_size('5Gi')])
yamls = find_write_template_calls(fs)
assert yamls[0] == {
'apiVersion': 'v1',
'kind': 'PersistentVolumeClaim',
'metadata': {
'name': 'test-volume'
},
'spec': {
'accessModes': ['ReadWriteOnce'],
'resources': {
'requests': {
'storage': '5Gi'
}
},
'volumeMode': 'Filesystem'
}
}
def _run_dsl(args):
fs: MockFileSystem = args['file_system']
cluster_name = 'prod-us-east1'
project_id = 'project1'
service_account_b64 = b64encode(
json.dumps({
'key': 'someKey'
}).encode('utf-8'))
_, result = run_in_cluster(
conn=gke_conn(cluster_name, project_id, service_account_b64),
templates=[
micro_service('test', "test-service:1.0.0", 3000).with_sidecar(
container('my-sidecar',
'my-sidecar:1.0.0').with_volume_mount(
'my-volume', 'var/data/sidecar-data').
with_environment_from_context('ENV',
lambda c: c('cluster_name')))
])
deployment = find_write_template_calls(fs)[1]
microservice = deployment['spec']['template']['spec']['containers'][1]
assert microservice['env'][1]['name'] == 'ENV'
assert microservice['env'][1]['value'] == 'prod-us-east1'
def _run_dsl(args):
fs: MockFileSystem = args['file_system']
os: MockOsSystem = args["os_system"]
project_id = "project1"
cluster_name = 'prod-us-east1'
kubectl_version = "v1.15.3"
service_account_b64 = b64encode(
json.dumps({
'key': 'someKey'
}).encode('utf-8'))
os.mock_clusters_list([cluster_name])
os.mock_kubernetes_release(E.success(kubectl_version))
os.mock_download_install_kubectl(kubectl_version, E.success())
os.mock_create_kube_config(cluster_name, E.success())
os.mock_kubectl(cluster_name, 'get mappings', E.success())
os.mock_kubectl(cluster_name, 'get virtualservices',
E.failure('No such resource'))
_, result = run_in_cluster(
conn=gke_conn(cluster_name, project_id, service_account_b64),
templates=[
gateway_mapping('api', '*', 'api.default.svc.cluster.local')
])
yamls = find_write_template_calls(fs)
output_yaml = yamls[0]
assert output_yaml == {
'apiVersion': 'getambassador.io/v1',
'kind': 'Mapping',
'metadata': {
'name': 'api-mapping'
},
'spec': {
'prefix': '/',
'service': 'api.default.svc.cluster.local'
}
}
def _run_dsl(args):
os: MockOsSystem = args["os_system"]
fs: MockFileSystem = args["file_system"]
project_id = "project1"
app_name = 'test-service'
cluster_name = 'prod-us-east1'
kubectl_version = "v1.15.3"
service_account_b64 = b64encode(json.dumps({'key': 'someKey'}).encode('utf-8'))
os.mock_clusters_list([cluster_name])
os.mock_kubernetes_release(E.success(kubectl_version))
os.mock_download_install_kubectl(kubectl_version, E.success())
os.mock_create_kube_config(cluster_name, E.success())
os.mock_kubectl_apply_temp_file(cluster_name, E.success())
_, result = run_in_cluster(
conn=gke_conn(cluster_name, project_id, service_account_b64),
templates=[
deployment(app_name)
.with_empty_volume(name='test-volume')
.with_container(container('test', 'test:100'))
.with_container(container('test-2', 'test-2:100'))
]
)
deployment_yaml = find_write_template_calls(fs)[0]
assert deployment_yaml['kind'] == 'Deployment'
assert deployment_yaml['metadata']['name'] == app_name+'-dp'
assert deployment_yaml['spec']['selector']['matchLabels']['app'] == app_name+'-app'
assert deployment_yaml['spec']['template']['spec']['volumes'][0]['name'] == 'test-volume'
container1 = deployment_yaml['spec']['template']['spec']['containers'][0]
container2 = deployment_yaml['spec']['template']['spec']['containers'][1]
assert container1['name'] == 'test-app'
assert container1['image'] == 'test:100'
assert container2['name'] == 'test-2-app'
assert container2['image'] == 'test-2:100'
