def test_helm(k8s_cluster):
with k8s_cluster.create_resources([
NGINX_YAML_PATH
]), tiller_rbac_resources(k8s_cluster), fake_backend.start() as backend:
init_helm(k8s_cluster)
with k8s_cluster.run_tunnels(backend) as proxy_pod_ip:
with release_values_yaml(k8s_cluster, proxy_pod_ip,
backend) as values_path:
install_helm_chart(k8s_cluster, values_path)
try:
assert wait_for(
p(has_datapoint,
backend,
dimensions={"plugin": "nginx"}))
assert wait_for(
p(has_datapoint,
backend,
dimensions={"plugin": "signalfx-metadata"}))
finally:
for pod in get_pods_by_labels(
"app=signalfx-agent",
namespace=k8s_cluster.test_namespace):
print("pod/%s:" % pod.metadata.name)
status = exec_pod_command(
pod.metadata.name,
AGENT_STATUS_COMMAND,
namespace=k8s_cluster.test_namespace)
print("Agent Status:\n%s" % status)
logs = get_pod_logs(
pod.metadata.name,
namespace=k8s_cluster.test_namespace)
print("Agent Logs:\n%s" % logs)
def get_logs(self):
output = ""
for pod in self.pods:
output += "pod/%s\n" % pod.metadata.name
output += k8s.get_pod_logs(pod.metadata.name,
namespace=self.namespace) + "\n"
return output.strip()
def wait_for_deployments(self,
resources,
timeout_seconds=utils.K8S_CREATE_TIMEOUT):
for doc in filter(lambda d: d.kind == "Deployment", resources):
name = doc.metadata.name
namespace = doc.metadata.namespace
print("Waiting for deployment %s to be ready ..." % name)
try:
start_time = time.time()
assert wait_for(
p(utils.deployment_is_ready, name, namespace),
timeout_seconds=timeout_seconds,
interval_seconds=2
), 'timed out waiting for deployment "%s" to be ready!\n%s' % (
name,
utils.get_pod_logs(name, namespace),
)
print("Waited %d seconds" % (time.time() - start_time))
finally:
print(
self.exec_kubectl(f"describe deployment {name}",
namespace=namespace))
for pod in utils.get_all_pods(namespace):
print(
self.exec_kubectl(f"describe pod {pod.metadata.name}",
namespace=namespace))
def test_helm(k8s_cluster, helm_version):
helm_major_version = int(helm_version.split(".")[0])
with run_helm_image(k8s_cluster, helm_version) as cont:
with k8s_cluster.create_resources(
[APP_YAML_PATH]), tiller_rbac_resources(
k8s_cluster,
helm_major_version), fake_backend.start() as backend:
if helm_major_version < 3:
init_helm(k8s_cluster, cont, helm_major_version)
with k8s_cluster.run_tunnels(backend) as proxy_pod_ip:
with release_values_yaml(k8s_cluster, proxy_pod_ip,
backend) as values_path:
copy_file_into_container(values_path, cont, values_path)
install_helm_chart(k8s_cluster, values_path, cont,
helm_major_version)
try:
assert wait_for(
p(
has_datapoint,
backend,
dimensions={
"container_name": "prometheus",
"application": "helm-test"
},
),
timeout_seconds=60,
)
assert wait_for(p(
has_datapoint,
backend,
dimensions={"plugin": "signalfx-metadata"}),
timeout_seconds=60)
finally:
for pod in get_pods_by_labels(
"app=signalfx-agent",
namespace=k8s_cluster.test_namespace):
print("pod/%s:" % pod.metadata.name)
status = exec_pod_command(
pod.metadata.name,
AGENT_STATUS_COMMAND,
namespace=k8s_cluster.test_namespace)
print("Agent Status:\n%s" % status)
logs = get_pod_logs(
pod.metadata.name,
namespace=k8s_cluster.test_namespace)
print("Agent Logs:\n%s" % logs)
print("\nDatapoints received:")
for dp in backend.datapoints:
print_dp_or_event(dp)
print("\nEvents received:")
for event in backend.events:
print_dp_or_event(event)
print(f"\nDimensions set: {backend.dims}")
def wait_for_deployments():
for doc in filter(lambda d: d["kind"] == "Deployment",
self.resources):
name = doc["metadata"]["name"]
nspace = doc["metadata"]["namespace"]
print("Waiting for deployment %s to be ready ..." % name)
try:
start_time = time.time()
assert wait_for(
p(k8s.deployment_is_ready, name, nspace),
timeout_seconds=timeout,
interval_seconds=2
), 'timed out waiting for deployment "%s" to be ready!\n%s' % (
name, k8s.get_pod_logs(name, nspace))
print("Waited %d seconds" % (time.time() - start_time))
finally:
print(
self.exec_kubectl("describe deployment %s" % name,
namespace=nspace))
for pod in k8s.get_all_pods(nspace):
print(
self.exec_kubectl("describe pod %s" %
pod.metadata.name,
namespace=nspace))
def deploy_fake_backend_proxy_pod(namespace):
"""
Deploys a socat pod named "fake-backend" that is ready to be used to
tunnel datapoints back to this process.
"""
corev1 = kube_client.CoreV1Api()
pod_yaml = Path(SCRIPT_DIR / "tunnel/pod.yaml").read_bytes()
pod = corev1.create_namespaced_pod(body=yaml.safe_load(pod_yaml),
namespace=namespace)
name = pod.metadata.name
try:
assert wait_for(p(pod_is_ready, name, namespace=namespace),
timeout_seconds=K8S_CREATE_TIMEOUT)
yield corev1.read_namespaced_pod(name,
namespace=namespace).status.pod_ip
finally:
print("Fake backend proxy logs: %s" %
(get_pod_logs(name, namespace=namespace)))
corev1.delete_namespaced_pod(
name,
namespace=namespace,
body=kube_client.V1DeleteOptions(grace_period_seconds=0,
propagation_policy="Background"),
)
def get_container_logs(self):
return get_pod_logs(self.container_name, namespace=self.namespace)