def create_game_service(api, name, _config):
service = Service(
api,
{
'kind': 'Service',
'apiVersion': 'v1',
'metadata': {
'name': "game-%s" % name,
'labels': {
'app': 'aimmo-game',
'game': name,
},
},
'spec': {
'selector': {
'app': 'aimmo-game',
'game': name,
},
'ports': [
{
'protocol': 'TCP',
'port': 80,
'targetPort': 5000,
},
],
'type': 'NodePort',
},
},
)
service.create()
def create_game_service(api, name, _config):
service = Service(
api,
{
'kind': 'Service',
'apiVersion': 'v1',
'metadata': {
'name': "game-%s" % name,
'labels': {
'app': 'aimmo-game',
'game': name,
},
},
'spec': {
'selector': {
'app': 'aimmo-game',
'game': name,
},
'ports': [
{
'protocol': 'TCP',
'port': 80,
'targetPort': 5000,
},
],
'type': 'NodePort',
},
},
)
service.create()
def find_backend_application(client, ingress, rule):
'''
The Ingress object might not have a "application" label, so let's try to find the application by looking at the backend service and its pods
'''
paths = rule.get('http', {}).get('paths', [])
selectors = []
for path in paths:
service_name = path.get('backend', {}).get('serviceName')
if service_name:
try:
service = Service.objects(
client, namespace=ingress.namespace).get(name=service_name)
except ObjectDoesNotExist:
logger.debug(
f'Referenced service does not exist: {ingress.namespace}/{service_name}'
)
else:
selector = service.obj['spec'].get('selector', {})
selectors.append(selector)
application = get_application_from_labels(selector)
if application:
return application
# we still haven't found the application, let's look up pods by label selectors
for selector in selectors:
application_candidates = set()
for pod in Pod.objects(client).filter(namespace=ingress.namespace,
selector=selector):
application = get_application_from_labels(pod.labels)
if application:
application_candidates.add(application)
if len(application_candidates) == 1:
return application_candidates.pop()
return ''
def start(self, object_type, object_file_path, force=False):
if not self.api:
logging.info('API Client does not exist')
return
with open(object_file_path) as json_data:
json_file = json.load(json_data)
if object_type is KubernetesObjects.POD:
pod = Pod(self.api, json_file)
self._recreate_object(pod, force)
self._add_object_to_kube_objects_dict('pods', pod)
elif object_type is KubernetesObjects.SERVICE:
service = Service(self.api, json_file)
self._recreate_object(service, force)
self._add_object_to_kube_objects_dict('services', service)
elif object_type is KubernetesObjects.REPLICATION_CONTROLLER:
rc = ReplicationController(self.api, json_file)
self._recreate_object(rc, force)
self._add_object_to_kube_objects_dict('rcs', rc)
def delete(body, meta, spec, status, **kwargs):
api = K8SApi.from_env()
deployment_name = f"{meta['name']}-{LAYER}"
logger.info(f"Deleting deployment {deployment_name} ...")
try:
deployment = Deployment.objects(api).filter(
namespace=meta["namespace"]).get(name=deployment_name)
deployment.delete()
except ObjectDoesNotExist:
logger.warning(f"Deployment {deployment_name} doesn't exist")
logger.info(f"Deleting deployment {deployment_name} ... done!")
service_name = f"{meta['name']}"
logger.info(f"Deleting service {service_name} ...")
try:
service = Service.objects(api).filter(namespace=meta["namespace"]).get(
name=service_name)
service.delete()
except ObjectDoesNotExist:
logger.warning(f"Service {service_name} doesn't exist")
logger.info(f"Deleting service {service_name} ... done!")
api.session.close()
return {'job1-status': 100}
def test_services(kube_cluster: Cluster):
services_response = Service.objects(
kube_cluster.kube_client).filter(namespace="default")
for service_name in [
"apiserver", "giantswarm-todo-app-mysql", "todomanager"
]:
service = services_response.get_by_name(service_name)
assert service is not None
def create(body, meta, spec, status, **kwargs):
api = K8SApi.from_env()
logger.info("Creating deployment ...")
deployment_data = create_deployment_data(meta, spec)
kopf.adopt(deployment_data)
# kopf.label(pod_data, {'application': 'kopf-example-10'})
deployment = Deployment(api, deployment_data)
if deployment.exists():
deployment.update()
else:
deployment.create()
logger.info("Creating deployment ... done!")
logger.info("Creating service ...")
service_data = create_service_data(meta, spec)
kopf.adopt(service_data)
service = Service(api, service_data)
if service.exists():
service.update()
else:
service.create()
logger.info("Creating service ... done!")
api.session.close()
return {'job1-status': 100}
def delete(namespace, names, logger):
api = HTTPClient(KubeConfig.from_file())
for name in names:
deploy = Deployment.objects(api, namespace=namespace).get(name=name)
deploy.delete()
logger.info(f'delete Deployment: {str(deploy)}')
service = Service.objects(api, namespace=namespace).get(name=name)
service.delete()
logger.info(f'delete Service: {str(service)}')
def get_application_label_from_service(client: pykube.HTTPClient, namespace,
service_name):
try:
service = Service.objects(client,
namespace=namespace).get(name=service_name)
except ObjectDoesNotExist:
logger.debug(
f"Referenced service does not exist: {namespace}/{service_name}")
return None, None
else:
selector = service.obj["spec"].get("selector", {})
application = get_application_from_labels(selector)
if application:
return application, []
return "", selector
def test_get_todos(kube_cluster: Cluster, cluster_type: str,
chart_extra_info: Dict[str, str]):
# unfortunately, when services and deployments are ready, traffic forwarding doesn't yet
# work fo 100% :( That's why we need a retry.
logger.info(
f"Running on cluster of type {cluster_type}, extra info is: {chart_extra_info}"
)
apiserver_service = (Service.objects(kube_cluster.kube_client).filter(
namespace="default").get(name="apiserver"))
res = proxy_http_get(kube_cluster.kube_client, apiserver_service,
"v1/todo")
assert res is not None
assert res.content == b"null\n"
assert res.status_code == 200
assert "Content-Type" in res.headers
assert res.headers["Content-Type"] == "application/json; charset=utf-8"
def create_helloworld_service(api, organization_name, tenant_name, space_name,
service_name):
obj = yaml.safe_load(f"""
kind: Service
apiVersion: v1
metadata:
namespace: org-{organization_name}-tenant-{tenant_name}-space-{space_name}
name: {service_name}
spec:
selector:
app: {service_name}
ports:
- protocol: TCP
port: 80
targetPort: 8080
""")
return Service(api, obj)
def test_create_delete_todo_entry(kube_cluster: Cluster):
apiserver_service = (Service.objects(kube_cluster.kube_client).filter(
namespace="default").get(name="apiserver"))
body = '{"Text":"testing"}'
headers = {"Content-Type": "application/json"}
res = proxy_http_post(
kube_cluster.kube_client,
apiserver_service,
"v1/todo",
data=body,
headers=headers,
)
assert res is not None
assert res.status_code == 200
todo_id = json.loads(res.text)["id"]
res = proxy_http_delete(kube_cluster.kube_client, apiserver_service,
f"v1/todo/{todo_id}")
assert res is not None
assert res.status_code == 200
def test_stormforger_load_app_creation(
kube_cluster: Cluster,
stormforger_load_app_factory: StormforgerLoadAppFactoryFunc) -> None:
"""This test deploys stormforger_load_app and checks if it response to basic requests.
To make this example run, you need a ready cluster with Giant Swarm App Platform.
The easiest way to create it is to run: `kube-app-testing.sh -j`.
"""
loadtest_app = stormforger_load_app_factory(1, "test.local", None)
assert loadtest_app.app is not None
wait_for_deployments_to_run(kube_cluster.kube_client,
[loadtest_app.app.name],
loadtest_app.app.namespace, 60)
srv: Service = Service.objects(kube_cluster.kube_client,
loadtest_app.app.namespace).get_by_name(
loadtest_app.app.name)
assert srv is not None
res = srv.proxy_http_get("/", headers={"Host": "test.local"})
assert res is not None
assert res.ok
assert res.status_code == 200
assert res.text.startswith("GET / HTTP/1.1\r\nHost: test.local\r\n")
def find_backend_application(client: pykube.HTTPClient, ingress: Ingress, rule):
"""
Find the application ID for a given Ingress object.
The Ingress object might not have a "application" label, so let's try to find the application by looking at the backend service and its pods
"""
paths = rule.get("http", {}).get("paths", [])
selectors = []
for path in paths:
service_name = path.get("backend", {}).get("serviceName")
if service_name:
try:
service = Service.objects(client, namespace=ingress.namespace).get(
name=service_name
)
except ObjectDoesNotExist:
logger.debug(
f"Referenced service does not exist: {ingress.namespace}/{service_name}"
)
else:
selector = service.obj["spec"].get("selector", {})
selectors.append(selector)
application = get_application_from_labels(selector)
if application:
return application
# we still haven't found the application, let's look up pods by label selectors
for selector in selectors:
application_candidates = set()
for pod in Pod.objects(client).filter(
namespace=ingress.namespace, selector=selector
):
application = get_application_from_labels(pod.labels)
if application:
application_candidates.add(application)
if len(application_candidates) == 1:
return application_candidates.pop()
return ""
def update(body, meta, spec, status, **kwargs):
api = K8SApi.from_env()
logger.info(f"Updating fog rollout {meta['name']} ...")
deployment_data = create_deployment_data(meta, spec)
kopf.adopt(deployment_data)
deployment = Deployment(api, deployment_data)
if deployment.exists():
logger.info(f"Updating deployment {deployment.name} ...")
deployment.update()
logger.info(f"Updating deployment {deployment.name} ... done!")
else:
logger.warning(f"Deployment {deployment.name} doesn't exist")
logger.info(f"Creating deployment {deployment.name} ...")
deployment.create()
logger.info(f"Creating deployment {deployment.name} ... done!")
service_data = create_service_data(meta, spec)
kopf.adopt(service_data)
service = Service(api, service_data)
if service.exists():
logger.info(f"Updating service {service.name} ...")
service.update()
logger.info(f"Updating service {service.name} ... done!")
else:
logger.warning(f"Service {service.name} doesn't exist")
logger.info(f"Creating service {service.name} ...")
service.create()
logger.info(f"Creating service {service.name} ... done!")
logger.info(f"Updating fog rollout {meta['name']} ... done!")
api.session.close()
return {'job1-status': 100}