####################################################################################
"""
service_account = "osm"
+ _STABLE_REPO_URL = "https://charts.helm.sh/stable"
def __init__(
self,
helm_command: str = "/usr/bin/helm",
log: object = None,
on_update_db=None,
+ vca_config: dict = None,
):
"""
self._helm_command = helm_command
self._check_file_exists(filename=helm_command, exception_if_not_exists=True)
+ # obtain stable repo url from config or apply default
+ if not vca_config or not vca_config.get("stablerepourl"):
+ self._stable_repo_url = self._STABLE_REPO_URL
+ else:
+ self._stable_repo_url = vca_config.get("stablerepourl")
+
# initialize helm client-only
self.log.debug("Initializing helm client-only...")
- command = "{} init --client-only".format(self._helm_command)
+ command = "{} init --client-only --stable-repo-url {}".format(
+ self._helm_command, self._stable_repo_url)
try:
asyncio.ensure_future(
self._local_async_exec(command=command, raise_exception_on_error=False)
_, _rc = await self._local_async_exec(command=command, raise_exception_on_error=False)
command = ("{} --kubeconfig={} --tiller-namespace={} --home={} --service-account {} "
- "init").format(self._helm_command, config_filename, namespace, helm_dir,
- self.service_account)
+ " --stable-repo-url {} init").format(self._helm_command,
+ config_filename,
+ namespace, helm_dir,
+ self.service_account,
+ self._stable_repo_url)
_, _rc = await self._local_async_exec(command=command, raise_exception_on_error=True)
n2vc_installed_sw = True
else:
self.log.info("Initializing helm in client: {}".format(cluster_id))
command = (
"{} --kubeconfig={} --tiller-namespace={} "
- "--home={} init --client-only"
- ).format(self._helm_command, config_filename, namespace, helm_dir)
+ "--home={} init --client-only --stable-repo-url {} "
+ ).format(self._helm_command, config_filename, namespace,
+ helm_dir, self._stable_repo_url)
output, _rc = await self._local_async_exec(
command=command, raise_exception_on_error=True
)
else:
self.log.info("Helm client already initialized")
+ # remove old stable repo and add new one
+ cluster_uuid = "{}:{}".format(namespace, cluster_id)
+ repo_list = await self.repo_list(cluster_uuid)
+ for repo in repo_list:
+ if repo["Name"] == "stable" and repo["URL"] != self._stable_repo_url:
+ self.log.debug("Add new stable repo url: {}")
+ await self.repo_remove(cluster_uuid,
+ "stable")
+ await self.repo_add(cluster_uuid,
+ "stable",
+ self._stable_repo_url)
+ break
+
self.log.info("Cluster {} initialized".format(cluster_id))
return cluster_uuid, n2vc_installed_sw
) -> bool:
namespace, cluster_id = self._get_namespace_cluster_id(cluster_uuid)
- self.log.debug(
- "Resetting K8s environment. cluster uuid: {}".format(cluster_id)
- )
+ self.log.debug("Resetting K8s environment. cluster uuid: {} uninstall={}"
+ .format(cluster_id, uninstall_sw))
# get kube and helm directories
_kube_dir, helm_dir, config_filename, _cluster_dir = self._get_paths(
cluster_name=cluster_id, create_if_not_exist=False
)
- # uninstall releases if needed
- releases = await self.instances_list(cluster_uuid=cluster_uuid)
- if len(releases) > 0:
- if force:
- for r in releases:
- try:
- kdu_instance = r.get("Name")
- chart = r.get("Chart")
- self.log.debug(
- "Uninstalling {} -> {}".format(chart, kdu_instance)
- )
- await self.uninstall(
- cluster_uuid=cluster_uuid, kdu_instance=kdu_instance
- )
- except Exception as e:
- self.log.error(
- "Error uninstalling release {}: {}".format(kdu_instance, e)
- )
- else:
- msg = (
- "Cluster has releases and not force. Cannot reset K8s "
- "environment. Cluster uuid: {}"
- ).format(cluster_id)
- self.log.error(msg)
- raise K8sException(msg)
+ # uninstall releases if needed.
+ if uninstall_sw:
+ releases = await self.instances_list(cluster_uuid=cluster_uuid)
+ if len(releases) > 0:
+ if force:
+ for r in releases:
+ try:
+ kdu_instance = r.get("Name")
+ chart = r.get("Chart")
+ self.log.debug(
+ "Uninstalling {} -> {}".format(chart, kdu_instance)
+ )
+ await self.uninstall(
+ cluster_uuid=cluster_uuid, kdu_instance=kdu_instance
+ )
+ except Exception as e:
+ self.log.error(
+ "Error uninstalling release {}: {}".format(kdu_instance, e)
+ )
+ else:
+ msg = (
+ "Cluster uuid: {} has releases and not force. Leaving K8s helm environment"
+ ).format(cluster_id)
+ self.log.warn(msg)
+ uninstall_sw = False # Allow to remove k8s cluster without removing Tiller
if uninstall_sw:
kdu_instance: str,
namespace: str) -> list:
+ _, cluster_id = self._get_namespace_cluster_id(cluster_uuid)
self.log.debug(
"get_services: cluster_uuid: {}, kdu_instance: {}".format(
cluster_uuid, kdu_instance
)
status = await self._status_kdu(
- cluster_uuid, kdu_instance, return_text=False
+ cluster_id, kdu_instance, return_text=False
)
service_names = self._parse_helm_status_service_info(status)
)
# get paths
+ _, cluster_id = self._get_namespace_cluster_id(cluster_uuid)
_kube_dir, helm_dir, config_filename, _cluster_dir = self._get_paths(
- cluster_name=cluster_uuid, create_if_not_exist=True
+ cluster_name=cluster_id, create_if_not_exist=True
)
command = "{} --kubeconfig={} --namespace={} get service {} -o=yaml".format(
async def synchronize_repos(self, cluster_uuid: str):
_, cluster_id = self._get_namespace_cluster_id(cluster_uuid)
- self.log.debug("syncronize repos for cluster helm-id: {}",)
+ self.log.debug("syncronize repos for cluster helm-id: {}".format(cluster_id))
try:
update_repos_timeout = (
300 # max timeout to sync a single repos, more than this is too much
# elements that must be deleted
deleted_repo_list = []
added_repo_dict = {}
- self.log.debug("helm_chart_repos: {}".format(nbi_repo_list))
- self.log.debug("helm_charts_added: {}".format(cluster_repo_dict))
+ # self.log.debug("helm_chart_repos: {}".format(nbi_repo_list))
+ # self.log.debug("helm_charts_added: {}".format(cluster_repo_dict))
# obtain repos to add: registered by nbi but not added
repos_to_add = [
# delete repos: must delete first then add because there may be
# different repos with same name but
# different id and url
- self.log.debug("repos to delete: {}".format(repos_to_delete))
+ if repos_to_delete:
+ self.log.debug("repos to delete: {}".format(repos_to_delete))
for repo_id in repos_to_delete:
# try to delete repos
try:
deleted_repo_list.append(repo_id)
# add repos
- self.log.debug("repos to add: {}".format(repos_to_add))
+ if repos_to_add:
+ self.log.debug("repos to add: {}".format(repos_to_add))
for repo_id in repos_to_add:
# obtain the repo data from the db
# if there is an error getting the repo in the database we will
db_dict: dict = None,
run_once: bool = False,
):
+ previous_exception = None
while True:
try:
await asyncio.sleep(check_every)
self.log.debug("Task cancelled")
return
except Exception as e:
- self.log.debug("_store_status exception: {}".format(str(e)), exc_info=True)
- pass
+ # log only once in the while loop
+ if str(previous_exception) != str(e):
+ self.log.debug("_store_status exception: {}".format(str(e)))
+ previous_exception = e
finally:
if run_once:
return
projects / osm / N2VC.git / blobdiff