helm_command: str = "/usr/bin/helm",
log: object = None,
on_update_db=None,
+ vca_config: dict = None,
):
"""
Initializes helm connector for helm v2
kubectl_command=kubectl_command,
helm_command=helm_command,
on_update_db=on_update_db,
+ vca_config=vca_config,
)
self.log.info("Initializing K8S Helm2 connector")
# 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)
self,
cluster_uuid: str,
kdu_model: str,
+ kdu_instance: str,
atomic: bool = True,
timeout: float = 300,
params: dict = None,
db_dict: dict = None,
kdu_name: str = None,
namespace: str = None,
+ **kwargs,
):
+ """
+ Deploys of a new KDU instance. It would implicitly rely on the `install` call
+ to deploy the Chart/Bundle properly parametrized (in practice, this call would
+ happen before any _initial-config-primitive_of the VNF is called).
+
+ :param cluster_uuid: UUID of a K8s cluster known by OSM
+ :param kdu_model: chart/ reference (string), which can be either
+ of these options:
+ - a name of chart available via the repos known by OSM
+ - a path to a packaged chart
+ - a path to an unpacked chart directory or a URL
+ :param kdu_instance: Kdu instance name
+ :param atomic: If set, installation process purges chart/bundle on fail, also
+ will wait until all the K8s objects are active
+ :param timeout: Time in seconds to wait for the install of the chart/bundle
+ (defaults to Helm default timeout: 300s)
+ :param params: dictionary of key-value pairs for instantiation parameters
+ (overriding default values)
+ :param dict db_dict: where to write into database when the status changes.
+ It contains a dict with {collection: <str>, filter: {},
+ path: <str>},
+ e.g. {collection: "nsrs", filter:
+ {_id: <nsd-id>, path: "_admin.deployed.K8S.3"}
+ :param kdu_name: Name of the KDU instance to be installed
+ :param namespace: K8s namespace to use for the KDU instance
+ :param kwargs: Additional parameters (None yet)
+ :return: True if successful
+ """
_, cluster_id = self._get_namespace_cluster_id(cluster_uuid)
self.log.debug("installing {} in cluster {}".format(kdu_model, cluster_id))
cluster_name=cluster_id, create_if_not_exist=True
)
- kdu_instance = await self._install_impl(cluster_id,
- kdu_model,
- paths,
- env,
- atomic=atomic,
- timeout=timeout,
- params=params,
- db_dict=db_dict,
- kdu_name=kdu_name,
- namespace=namespace)
+ await self._install_impl(
+ cluster_id,
+ kdu_model,
+ paths,
+ env,
+ kdu_instance,
+ atomic=atomic,
+ timeout=timeout,
+ params=params,
+ db_dict=db_dict,
+ kdu_name=kdu_name,
+ namespace=namespace,
+ )
# sync fs
self.fs.reverse_sync(from_path=cluster_id)
self.log.debug("Returning kdu_instance {}".format(kdu_instance))
- return kdu_instance
+ return True
async def inspect_kdu(self, kdu_model: str, repo_url: str = None) -> str:
command = (
"{} --kubeconfig={} --tiller-namespace={} --home={} --service-account {} "
- "init"
+ " --stable-repo-url {} init"
).format(
self._helm_command,
paths["kube_config"],
namespace,
paths["helm_dir"],
self.service_account,
+ self._stable_repo_url
)
_, _rc = await self._local_async_exec(
command=command, raise_exception_on_error=True, env=env
self.log.info("Initializing helm in client: {}".format(cluster_id))
command = (
"{} --kubeconfig={} --tiller-namespace={} "
- "--home={} init --client-only"
+ "--home={} init --client-only --stable-repo-url {} "
).format(
self._helm_command,
paths["kube_config"],
namespace,
paths["helm_dir"],
+ self._stable_repo_url,
)
output, _rc = await self._local_async_exec(
command=command, raise_exception_on_error=True, env=env
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
+
return n2vc_installed_sw
async def _uninstall_sw(self, cluster_id: str, namespace: str):