def k8s_cluster(request):
agent_image_name = request.config.getoption("--agent-image-name")
conf = request.config
kube_context = None
if conf.getoption("--kubeconfig") or conf.getoption(
"--kube-context") or conf.getoption("--no-use-minikube"):
assert agent_image_name, "You must specify the agent image name when not using minikube"
kube_config_path = conf.getoption("--kubeconfig")
kube_context = conf.getoption("--kube-context")
else:
minikube_container_name = conf.getoption("--minikube-container-name")
dclient = get_docker_client()
assert get_docker_client().containers.get(
minikube_container_name
), f"You must start the minikube container ({minikube_container_name}) before running pytest by running `make minikube`."
# Pull the kubeconfig out of the minikube container and make a cluster instance based on it.
minikube_cont = dclient.containers.get(minikube_container_name)
_, kubeconfig_bytes = minikube_cont.exec_run("cat /kubeconfig")
_, kube_config_path = tempfile.mkstemp()
request.addfinalizer(lambda: os.remove(kube_config_path))
with open(kube_config_path, "wb") as fd:
fd.write(kubeconfig_bytes)
if not agent_image_name:
agent_image_name = "localhost:5000/signalfx-agent:latest"
cluster = Cluster(kube_config_path=kube_config_path,
kube_context=kube_context,
agent_image_name=agent_image_name)
request.addfinalizer(cluster.delete_test_namespace)
return cluster
def kong_image():
dockerfile = BytesIO(
bytes(
dedent(r"""
from kong:0.13-centos
RUN yum install -y epel-release
RUN yum install -y postgresql git
WORKDIR /usr/local/share/lua/5.1/kong
RUN sed -i '38ilua_shared_dict kong_signalfx_aggregation 10m;' templates/nginx_kong.lua
RUN sed -i '38ilua_shared_dict kong_signalfx_locks 100k;' templates/nginx_kong.lua
RUN sed -i '29i\ \ "signalfx",' constants.lua
WORKDIR /opt/
RUN git clone --depth 1 https://github.com/signalfx/kong-plugin-signalfx.git
RUN cd kong-plugin-signalfx && luarocks make
WORKDIR /
RUN mkdir -p /usr/local/kong/logs
RUN ln -s /dev/stderr /usr/local/kong/logs/error.log
RUN ln -s /dev/stdout /usr/local/kong/logs/access.log
"""),
"ascii",
))
client = get_docker_client()
image, _ = client.images.build(fileobj=dockerfile, forcerm=True)
try:
yield image.short_id
finally:
client.images.remove(image=image.id, force=True)
def build_base_image(name, path=DOCKERFILES_DIR, dockerfile=None):
client = get_docker_client()
dockerfile = dockerfile or Path(path) / f"Dockerfile.{name}"
image, _ = client.images.build(path=str(path),
dockerfile=str(dockerfile),
pull=True,
rm=True,
forcerm=True)
return image.id
def build_base_image(name):
client = get_docker_client()
image, logs = client.images.build(path=DOCKERFILES_DIR,
dockerfile=os.path.join(
DOCKERFILES_DIR,
"Dockerfile.%s" % name),
rm=True,
forcerm=True)
return image.id
def build_base_image(name, path=DOCKERFILES_DIR, dockerfile=None):
client = get_docker_client()
if not dockerfile:
dockerfile = os.path.join(path, "Dockerfile.%s" % name)
image, _ = client.images.build(path=path,
dockerfile=dockerfile,
pull=True,
rm=True,
forcerm=True)
return image.id
def __init__(self):
self.agent = Agent()
self.client = None
self.cluster_name = None
self.container = None
self.container_ip = None
self.container_name = None
self.host_client = get_docker_client()
self.image_tag = None
self.k8s_version = None
self.kubeconfig = None
self.registry_port = 5000
self.resources = []
self.version = None
def __init__(self):
self.bootstrapper = None
self.container = None
self.client = None
self.version = None
self.k8s_version = None
self.name = None
self.host_client = get_docker_client()
self.yamls = []
self.agent = Agent()
self.cluster_name = "minikube"
self.kubeconfig = None
self.namespace = "default"
self.worker_id = "master"
self.registry_port = None
def agent_image(minikube, request, worker_id): # pylint: disable=redefined-outer-name
def teardown():
if temp_agent_name and temp_agent_tag:
try:
client.images.remove("%s:%s" % (temp_agent_name, temp_agent_tag))
except: # noqa pylint: disable=bare-except
pass
request.addfinalizer(teardown)
sfx_agent_name = os.environ.get("K8S_SFX_AGENT")
if not sfx_agent_name:
sfx_agent_name = request.config.getoption("--k8s-sfx-agent")
if sfx_agent_name:
try:
agent_image_name, agent_image_tag = sfx_agent_name.rsplit(":", maxsplit=1)
except ValueError:
agent_image_name = sfx_agent_name
agent_image_tag = "latest"
else:
agent_image_name = "signalfx-agent"
agent_image_tag = "k8s-test"
temp_agent_name = None
temp_agent_tag = None
client = get_docker_client()
if worker_id in ("master", "gw0"):
if sfx_agent_name and not has_docker_image(client, sfx_agent_name):
print('\nAgent image "%s" not found in local registry.' % sfx_agent_name)
print("Attempting to pull from remote registry to minikube ...")
sfx_agent_image = minikube.pull_agent_image(agent_image_name, agent_image_tag)
_, output = minikube.container.exec_run("docker images")
print(output.decode("utf-8"))
return {"name": agent_image_name, "tag": agent_image_tag, "id": sfx_agent_image.id}
if sfx_agent_name:
print('\nAgent image "%s" found in local registry.' % sfx_agent_name)
sfx_agent_image = client.images.get(sfx_agent_name)
else:
print(
'\nBuilding agent image from local source and tagging as "%s:%s" ...'
% (agent_image_name, agent_image_tag)
)
subprocess.run(
"make image",
shell=True,
env={"PULL_CACHE": "yes", "AGENT_IMAGE_NAME": agent_image_name, "AGENT_VERSION": agent_image_tag},
stderr=subprocess.STDOUT,
check=True,
cwd=REPO_ROOT_DIR,
timeout=K8S_SFX_AGENT_BUILD_TIMEOUT,
)
sfx_agent_image = client.images.get(agent_image_name + ":" + agent_image_tag)
temp_agent_name = "localhost:%d/signalfx-agent-dev" % minikube.registry_port
temp_agent_tag = "latest"
print("\nPushing agent image to minikube ...")
sfx_agent_image.tag(temp_agent_name, tag=temp_agent_tag)
client.images.push(temp_agent_name, tag=temp_agent_tag)
sfx_agent_image = minikube.pull_agent_image(temp_agent_name, temp_agent_tag, sfx_agent_image.id)
sfx_agent_image.tag(agent_image_name, tag=agent_image_tag)
_, output = minikube.container.exec_run("docker images")
print(output.decode("utf-8").strip())
else:
print("\nWaiting for agent image to be built/pulled to minikube ...")
assert wait_for(
p(has_docker_image, minikube.client, agent_image_name, agent_image_tag),
timeout_seconds=K8S_SFX_AGENT_BUILD_TIMEOUT,
interval_seconds=2,
), 'timed out waiting for agent image "%s:%s"!' % (agent_image_name, agent_image_tag)
sfx_agent_image = minikube.client.images.get(agent_image_name + ":" + agent_image_tag)
return {"name": agent_image_name, "tag": agent_image_tag, "id": sfx_agent_image.id}
