2 # Copyright 2020 Telefonica Investigacion y Desarrollo, S.A.U.
4 # Licensed under the Apache License, Version 2.0 (the "License");
5 # you may not use this file except in compliance with the License.
6 # You may obtain a copy of the License at
8 # http://www.apache.org/licenses/LICENSE-2.0
10 # Unless required by applicable law or agreed to in writing, software
11 # distributed under the License is distributed on an "AS IS" BASIS,
12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
14 # See the License for the specific language governing permissions and
15 # limitations under the License.
25 from grpclib
.client
import Channel
27 from osm_lcm
.data_utils
.lcm_config
import VcaConfig
28 from osm_lcm
.frontend_pb2
import PrimitiveRequest
29 from osm_lcm
.frontend_pb2
import SshKeyRequest
, SshKeyReply
30 from osm_lcm
.frontend_grpc
import FrontendExecutorStub
31 from osm_lcm
.lcm_utils
import LcmBase
, get_ee_id_parts
33 from osm_lcm
.data_utils
.database
.database
import Database
34 from osm_lcm
.data_utils
.filesystem
.filesystem
import Filesystem
36 from n2vc
.n2vc_conn
import N2VCConnector
37 from n2vc
.k8s_helm_conn
import K8sHelmConnector
38 from n2vc
.k8s_helm3_conn
import K8sHelm3Connector
39 from n2vc
.exceptions
import (
40 N2VCBadArgumentsException
,
42 N2VCExecutionException
,
45 from osm_lcm
.lcm_utils
import deep_get
48 def retryer(max_wait_time_var
="_initial_retry_time", delay_time_var
="_retry_delay"):
50 retry_exceptions
= (ConnectionRefusedError
, TimeoutError
)
52 @functools.wraps(func
)
53 async def wrapped(*args
, **kwargs
):
54 # default values for wait time and delay_time
58 # obtain arguments from variable names
60 if self
.__dict
__.get(max_wait_time_var
):
61 max_wait_time
= self
.__dict
__.get(max_wait_time_var
)
62 if self
.__dict
__.get(delay_time_var
):
63 delay_time
= self
.__dict
__.get(delay_time_var
)
65 wait_time
= max_wait_time
68 return await func(*args
, **kwargs
)
69 except retry_exceptions
:
70 wait_time
= wait_time
- delay_time
71 await asyncio
.sleep(delay_time
)
74 return ConnectionRefusedError
81 def create_secure_context(
84 ctx
= ssl
.SSLContext(ssl
.PROTOCOL_TLS_CLIENT
)
85 ctx
.verify_mode
= ssl
.CERT_REQUIRED
86 ctx
.check_hostname
= True
87 ctx
.minimum_version
= ssl
.TLSVersion
.TLSv1_2
89 # ctx.load_cert_chain(str(client_cert), str(client_key))
90 ctx
.load_verify_locations(trusted
)
91 ctx
.set_ciphers("ECDHE+AESGCM:ECDHE+CHACHA20:DHE+AESGCM:DHE+CHACHA20")
92 ctx
.set_alpn_protocols(["h2"])
96 class LCMHelmConn(N2VCConnector
, LcmBase
):
100 vca_config
: VcaConfig
= None,
104 Initialize EE helm connector.
107 self
.db
= Database().instance
.db
108 self
.fs
= Filesystem().instance
.fs
110 # parent class constructor
111 N2VCConnector
.__init
__(
112 self
, log
=log
, on_update_db
=on_update_db
, db
=self
.db
, fs
=self
.fs
115 self
.vca_config
= vca_config
116 self
.log
.debug("Initialize helm N2VC connector")
117 self
.log
.debug("initial vca_config: {}".format(vca_config
.to_dict()))
119 self
._retry
_delay
= self
.vca_config
.helm_ee_retry_delay
121 self
._initial
_retry
_time
= self
.vca_config
.helm_max_initial_retry_time
122 self
.log
.debug("Initial retry time: {}".format(self
._initial
_retry
_time
))
124 self
._max
_retry
_time
= self
.vca_config
.helm_max_retry_time
125 self
.log
.debug("Retry time: {}".format(self
._max
_retry
_time
))
127 # initialize helm connector for helmv2 and helmv3
128 self
._k
8sclusterhelm
2 = K8sHelmConnector(
129 kubectl_command
=self
.vca_config
.kubectlpath
,
130 helm_command
=self
.vca_config
.helmpath
,
137 self
._k
8sclusterhelm
3 = K8sHelm3Connector(
138 kubectl_command
=self
.vca_config
.kubectlpath
,
139 helm_command
=self
.vca_config
.helm3path
,
146 self
._system
_cluster
_id
= None
147 self
.log
.info("Helm N2VC connector initialized")
149 # TODO - ¿reuse_ee_id?
150 async def create_execution_environment(
154 reuse_ee_id
: str = None,
155 progress_timeout
: float = None,
156 total_timeout
: float = None,
158 artifact_path
: str = None,
159 chart_model
: str = None,
160 vca_type
: str = None,
165 Creates a new helm execution environment deploying the helm-chat indicated in the
167 :param str namespace: This param is not used, all helm charts are deployed in the osm
169 :param dict db_dict: where to write to database when the status changes.
170 It contains a dictionary with {collection: str, filter: {}, path: str},
171 e.g. {collection: "nsrs", filter: {_id: <nsd-id>, path:
172 "_admin.deployed.VCA.3"}
173 :param str reuse_ee_id: ee id from an older execution. TODO - right now this param is not used
174 :param float progress_timeout:
175 :param float total_timeout:
176 :param dict config: General variables to instantiate KDU
177 :param str artifact_path: path of package content
178 :param str chart_model: helm chart/reference (string), which can be either
180 - a name of chart available via the repos known by OSM
181 (e.g. stable/openldap, stable/openldap:1.2.4)
182 - a path to a packaged chart (e.g. mychart.tgz)
183 - a path to an unpacked chart directory or a URL (e.g. mychart)
184 :param str vca_type: Type of vca, must be type helm or helm-v3
185 :returns str, dict: id of the new execution environment including namespace.helm_id
186 and credentials object set to None as all credentials should be osm kubernetes .kubeconfig
190 "create_execution_environment: namespace: {}, artifact_path: {}, "
191 "chart_model: {}, db_dict: {}, reuse_ee_id: {}".format(
192 namespace
, artifact_path
, db_dict
, chart_model
, reuse_ee_id
196 # Validate artifact-path is provided
197 if artifact_path
is None or len(artifact_path
) == 0:
198 raise N2VCBadArgumentsException(
199 message
="artifact_path is mandatory", bad_args
=["artifact_path"]
202 # Validate artifact-path exists and sync path
203 from_path
= os
.path
.split(artifact_path
)[0]
204 self
.fs
.sync(from_path
)
206 # remove / in charm path
207 while artifact_path
.find("//") >= 0:
208 artifact_path
= artifact_path
.replace("//", "/")
211 if self
.fs
.file_exists(artifact_path
):
212 helm_chart_path
= artifact_path
214 msg
= "artifact path does not exist: {}".format(artifact_path
)
215 raise N2VCBadArgumentsException(message
=msg
, bad_args
=["artifact_path"])
217 if artifact_path
.startswith("/"):
218 full_path
= self
.fs
.path
+ helm_chart_path
220 full_path
= self
.fs
.path
+ "/" + helm_chart_path
222 while full_path
.find("//") >= 0:
223 full_path
= full_path
.replace("//", "/")
225 # By default, the KDU is expected to be a file
226 kdu_model
= full_path
227 # If the chart_model includes a "/", then it is a reference:
228 # e.g. (stable/openldap; stable/openldap:1.2.4)
229 if chart_model
.find("/") >= 0:
230 kdu_model
= chart_model
233 # Call helm conn install
234 # Obtain system cluster id from database
235 system_cluster_uuid
= await self
._get
_system
_cluster
_id
()
236 # Add parameter osm if exist to global
237 if config
and config
.get("osm"):
238 if not config
.get("global"):
239 config
["global"] = {}
240 config
["global"]["osm"] = config
.get("osm")
242 self
.log
.debug("install helm chart: {}".format(full_path
))
243 if vca_type
== "helm":
244 helm_id
= self
._k
8sclusterhelm
2.generate_kdu_instance_name(
248 await self
._k
8sclusterhelm
2.install(
251 kdu_instance
=helm_id
,
252 namespace
=self
.vca_config
.kubectl_osm_namespace
,
255 timeout
=progress_timeout
,
258 helm_id
= self
._k
8sclusterhelm
2.generate_kdu_instance_name(
262 await self
._k
8sclusterhelm
3.install(
265 kdu_instance
=helm_id
,
266 namespace
=self
.vca_config
.kubectl_osm_namespace
,
269 timeout
=progress_timeout
,
272 ee_id
= "{}:{}.{}".format(
273 vca_type
, self
.vca_config
.kubectl_osm_namespace
, helm_id
276 except N2VCException
:
278 except Exception as e
:
279 self
.log
.error("Error deploying chart ee: {}".format(e
), exc_info
=True)
280 raise N2VCException("Error deploying chart ee: {}".format(e
))
282 async def upgrade_execution_environment(
287 progress_timeout
: float = None,
288 total_timeout
: float = None,
290 artifact_path
: str = None,
291 vca_type
: str = None,
296 Creates a new helm execution environment deploying the helm-chat indicated in the
298 :param str namespace: This param is not used, all helm charts are deployed in the osm
300 :param dict db_dict: where to write to database when the status changes.
301 It contains a dictionary with {collection: str, filter: {}, path: str},
302 e.g. {collection: "nsrs", filter: {_id: <nsd-id>, path:
303 "_admin.deployed.VCA.3"}
304 :param helm_id: unique name of the Helm release to upgrade
305 :param float progress_timeout:
306 :param float total_timeout:
307 :param dict config: General variables to instantiate KDU
308 :param str artifact_path: path of package content
309 :param str vca_type: Type of vca, must be type helm or helm-v3
310 :returns str, dict: id of the new execution environment including namespace.helm_id
311 and credentials object set to None as all credentials should be osm kubernetes .kubeconfig
315 "upgrade_execution_environment: namespace: {}, artifact_path: {}, db_dict: {}, "
318 # Validate helm_id is provided
319 if helm_id
is None or len(helm_id
) == 0:
320 raise N2VCBadArgumentsException(
321 message
="helm_id is mandatory", bad_args
=["helm_id"]
324 # Validate artifact-path is provided
325 if artifact_path
is None or len(artifact_path
) == 0:
326 raise N2VCBadArgumentsException(
327 message
="artifact_path is mandatory", bad_args
=["artifact_path"]
330 # Validate artifact-path exists and sync path
331 from_path
= os
.path
.split(artifact_path
)[0]
332 self
.fs
.sync(from_path
)
334 # remove / in charm path
335 while artifact_path
.find("//") >= 0:
336 artifact_path
= artifact_path
.replace("//", "/")
339 if self
.fs
.file_exists(artifact_path
):
340 helm_chart_path
= artifact_path
342 msg
= "artifact path does not exist: {}".format(artifact_path
)
343 raise N2VCBadArgumentsException(message
=msg
, bad_args
=["artifact_path"])
345 if artifact_path
.startswith("/"):
346 full_path
= self
.fs
.path
+ helm_chart_path
348 full_path
= self
.fs
.path
+ "/" + helm_chart_path
350 while full_path
.find("//") >= 0:
351 full_path
= full_path
.replace("//", "/")
354 # Call helm conn upgrade
355 # Obtain system cluster id from database
356 system_cluster_uuid
= await self
._get
_system
_cluster
_id
()
357 # Add parameter osm if exist to global
358 if config
and config
.get("osm"):
359 if not config
.get("global"):
360 config
["global"] = {}
361 config
["global"]["osm"] = config
.get("osm")
363 self
.log
.debug("Ugrade helm chart: {}".format(full_path
))
364 if vca_type
== "helm":
365 await self
._k
8sclusterhelm
2.upgrade(
368 kdu_instance
=helm_id
,
372 timeout
=progress_timeout
,
376 await self
._k
8sclusterhelm
3.upgrade(
379 kdu_instance
=helm_id
,
383 timeout
=progress_timeout
,
387 except N2VCException
:
389 except Exception as e
:
390 self
.log
.error("Error upgrading chart ee: {}".format(e
), exc_info
=True)
391 raise N2VCException("Error upgrading chart ee: {}".format(e
))
393 async def create_tls_certificate(
399 namespace
: str = None,
401 # Obtain system cluster id from database
402 system_cluster_uuid
= await self
._get
_system
_cluster
_id
()
403 # use helm-v3 as certificates don't depend on helm version
404 await self
._k
8sclusterhelm
3.create_certificate(
405 cluster_uuid
=system_cluster_uuid
,
406 namespace
=namespace
or self
.vca_config
.kubectl_osm_namespace
,
407 dns_prefix
=dns_prefix
,
409 secret_name
=secret_name
,
413 async def delete_tls_certificate(
415 certificate_name
: str = None,
416 namespace
: str = None,
418 # Obtain system cluster id from database
419 system_cluster_uuid
= await self
._get
_system
_cluster
_id
()
420 await self
._k
8sclusterhelm
3.delete_certificate(
421 cluster_uuid
=system_cluster_uuid
,
422 namespace
=namespace
or self
.vca_config
.kubectl_osm_namespace
,
423 certificate_name
=certificate_name
,
426 async def register_execution_environment(
431 progress_timeout
: float = None,
432 total_timeout
: float = None,
439 async def install_configuration_sw(self
, *args
, **kwargs
):
443 async def add_relation(self
, *args
, **kwargs
):
447 async def remove_relation(self
):
451 async def get_status(self
, *args
, **kwargs
):
452 # not used for this connector
455 async def get_ee_ssh_public__key(
459 progress_timeout
: float = None,
460 total_timeout
: float = None,
464 Obtains ssh-public key from ee executing GetSShKey method from the ee.
466 :param str ee_id: the id of the execution environment returned by
467 create_execution_environment or register_execution_environment
469 :param float progress_timeout:
470 :param float total_timeout:
471 :returns: public key of the execution environment
475 "get_ee_ssh_public_key: ee_id: {}, db_dict: {}".format(ee_id
, db_dict
)
479 if ee_id
is None or len(ee_id
) == 0:
480 raise N2VCBadArgumentsException(
481 message
="ee_id is mandatory", bad_args
=["ee_id"]
485 # Obtain ip_addr for the ee service, it is resolved by dns from the ee name by kubernetes
486 version
, namespace
, helm_id
= get_ee_id_parts(ee_id
)
487 ip_addr
= "{}.{}.svc".format(helm_id
, namespace
)
488 # Obtain ssh_key from the ee, this method will implement retries to allow the ee
489 # install libraries and start successfully
490 ssh_key
= await self
._get
_ssh
_key
(ip_addr
)
492 except Exception as e
:
493 self
.log
.error("Error obtaining ee ssh_key: {}".format(e
), exc_info
=True)
494 raise N2VCException("Error obtaining ee ssh_ke: {}".format(e
))
496 async def upgrade_charm(
500 charm_id
: str = None,
501 charm_type
: str = None,
502 timeout
: float = None,
504 """This method upgrade charms in VNFs
506 This method does not support KDU's deployed with Helm.
509 ee_id: Execution environment id
510 path: Local path to the charm
512 charm_type: Charm type can be lxc-proxy-charm, native-charm or k8s-proxy-charm
513 timeout: (Float) Timeout for the ns update operation
516 the output of the update operation if status equals to "completed"
519 raise N2VCException("KDUs deployed with Helm do not support charm upgrade")
521 async def exec_primitive(
526 db_dict
: dict = None,
527 progress_timeout
: float = None,
528 total_timeout
: float = None,
532 Execute a primitive in the execution environment
534 :param str ee_id: the one returned by create_execution_environment or
535 register_execution_environment with the format namespace.helm_id
536 :param str primitive_name: must be one defined in the software. There is one
537 called 'config', where, for the proxy case, the 'credentials' of VM are
539 :param dict params_dict: parameters of the action
540 :param dict db_dict: where to write into database when the status changes.
541 It contains a dict with
542 {collection: <str>, filter: {}, path: <str>},
543 e.g. {collection: "nslcmops", filter:
544 {_id: <nslcmop_id>, path: "_admin.VCA"}
545 It will be used to store information about intermediate notifications
546 :param float progress_timeout:
547 :param float total_timeout:
548 :returns str: primitive result, if ok. It raises exceptions in case of fail
552 "exec primitive for ee_id : {}, primitive_name: {}, params_dict: {}, db_dict: {}".format(
553 ee_id
, primitive_name
, params_dict
, db_dict
558 if ee_id
is None or len(ee_id
) == 0:
559 raise N2VCBadArgumentsException(
560 message
="ee_id is mandatory", bad_args
=["ee_id"]
562 if primitive_name
is None or len(primitive_name
) == 0:
563 raise N2VCBadArgumentsException(
564 message
="action_name is mandatory", bad_args
=["action_name"]
566 if params_dict
is None:
570 version
, namespace
, helm_id
= get_ee_id_parts(ee_id
)
571 ip_addr
= "{}.{}.svc".format(helm_id
, namespace
)
572 except Exception as e
:
573 self
.log
.error("Error getting ee ip ee: {}".format(e
))
574 raise N2VCException("Error getting ee ip ee: {}".format(e
))
576 if primitive_name
== "config":
578 # Execute config primitive, higher timeout to check the case ee is starting
579 status
, detailed_message
= await self
._execute
_config
_primitive
(
580 ip_addr
, params_dict
, db_dict
=db_dict
583 "Executed config primitive ee_id_ {}, status: {}, message: {}".format(
584 ee_id
, status
, detailed_message
589 "Error configuring helm ee, status: {}, message: {}".format(
590 status
, detailed_message
593 raise N2VCExecutionException(
594 message
="Error configuring helm ee_id: {}, status: {}, message: {}: ".format(
595 ee_id
, status
, detailed_message
597 primitive_name
=primitive_name
,
599 except Exception as e
:
600 self
.log
.error("Error configuring helm ee: {}".format(e
))
601 raise N2VCExecutionException(
602 message
="Error configuring helm ee_id: {}, {}".format(ee_id
, e
),
603 primitive_name
=primitive_name
,
609 status
, detailed_message
= await self
._execute
_primitive
(
610 ip_addr
, primitive_name
, params_dict
, db_dict
=db_dict
613 "Executed primitive {} ee_id_ {}, status: {}, message: {}".format(
614 primitive_name
, ee_id
, status
, detailed_message
617 if status
!= "OK" and status
!= "PROCESSING":
619 "Execute primitive {} returned not ok status: {}, message: {}".format(
620 primitive_name
, status
, detailed_message
623 raise N2VCExecutionException(
624 message
="Execute primitive {} returned not ok status: {}, message: {}".format(
625 primitive_name
, status
, detailed_message
627 primitive_name
=primitive_name
,
629 except Exception as e
:
631 "Error executing primitive {}: {}".format(primitive_name
, e
)
633 raise N2VCExecutionException(
634 message
="Error executing primitive {} into ee={} : {}".format(
635 primitive_name
, ee_id
, e
637 primitive_name
=primitive_name
,
639 return detailed_message
641 async def deregister_execution_environments(self
):
645 async def delete_execution_environment(
648 db_dict
: dict = None,
649 total_timeout
: float = None,
653 Delete an execution environment
654 :param str ee_id: id of the execution environment to delete, included namespace.helm_id
655 :param dict db_dict: where to write into database when the status changes.
656 It contains a dict with
657 {collection: <str>, filter: {}, path: <str>},
658 e.g. {collection: "nsrs", filter:
659 {_id: <nsd-id>, path: "_admin.deployed.VCA.3"}
660 :param float total_timeout:
663 self
.log
.info("ee_id: {}".format(ee_id
))
667 raise N2VCBadArgumentsException(
668 message
="ee_id is mandatory", bad_args
=["ee_id"]
672 # Obtain cluster_uuid
673 system_cluster_uuid
= await self
._get
_system
_cluster
_id
()
676 version
, namespace
, helm_id
= get_ee_id_parts(ee_id
)
678 # Uninstall chart, for backward compatibility we must assume that if there is no
679 # version it is helm-v2
680 if version
== "helm-v3":
681 await self
._k
8sclusterhelm
3.uninstall(system_cluster_uuid
, helm_id
)
683 await self
._k
8sclusterhelm
2.uninstall(system_cluster_uuid
, helm_id
)
684 self
.log
.info("ee_id: {} deleted".format(ee_id
))
685 except N2VCException
:
687 except Exception as e
:
689 "Error deleting ee id: {}: {}".format(ee_id
, e
), exc_info
=True
691 raise N2VCException("Error deleting ee id {}: {}".format(ee_id
, e
))
693 async def delete_namespace(
694 self
, namespace
: str, db_dict
: dict = None, total_timeout
: float = None
696 # method not implemented for this connector, execution environments must be deleted individually
699 async def install_k8s_proxy_charm(
705 progress_timeout
: float = None,
706 total_timeout
: float = None,
713 @retryer(max_wait_time_var
="_initial_retry_time", delay_time_var
="_retry_delay")
714 async def _get_ssh_key(self
, ip_addr
):
715 return await self
._execute
_primitive
_internal
(
721 @retryer(max_wait_time_var
="_initial_retry_time", delay_time_var
="_retry_delay")
722 async def _execute_config_primitive(self
, ip_addr
, params
, db_dict
=None):
723 return await self
._execute
_primitive
_internal
(
724 ip_addr
, "config", params
, db_dict
=db_dict
727 @retryer(max_wait_time_var
="_max_retry_time", delay_time_var
="_retry_delay")
728 async def _execute_primitive(self
, ip_addr
, primitive_name
, params
, db_dict
=None):
729 return await self
._execute
_primitive
_internal
(
730 ip_addr
, primitive_name
, params
, db_dict
=db_dict
733 async def _execute_primitive_internal(
734 self
, ip_addr
, primitive_name
, params
, db_dict
=None
737 stub
= FrontendExecutorStub(channel
)
738 if primitive_name
== "_get_ssh_key":
739 self
.log
.debug("get ssh key, ip_addr: {}".format(ip_addr
))
740 reply
: SshKeyReply
= await stub
.GetSshKey(SshKeyRequest())
742 # For any other primitives
743 async with stub
.RunPrimitive
.open() as stream
:
744 primitive_id
= str(uuid
.uuid1())
747 "Execute primitive internal: id:{}, name:{}, params: {}".format(
748 primitive_id
, primitive_name
, params
751 await stream
.send_message(
753 id=primitive_id
, name
=primitive_name
, params
=yaml
.dump(params
)
757 async for reply
in stream
:
758 self
.log
.debug("Received reply: {}".format(reply
))
760 # If db_dict provided write notifs in database
762 self
._write
_op
_detailed
_status
(
763 db_dict
, reply
.status
, reply
.detailed_message
766 return reply
.status
, reply
.detailed_message
768 return "ERROR", "No result received"
770 ssl_context
= create_secure_context(self
.vca_config
.ca_store
)
772 ip_addr
, self
.vca_config
.helm_ee_service_port
, ssl
=ssl_context
775 return await execute()
776 except ssl
.SSLError
as ssl_error
: # fallback to insecure gRPC
778 ssl_error
.reason
== "WRONG_VERSION_NUMBER"
779 and not self
.vca_config
.eegrpc_tls_enforce
782 "Execution environment doesn't support TLS, falling back to unsecure gRPC"
784 channel
= Channel(ip_addr
, self
.vca_config
.helm_ee_service_port
)
785 return await execute()
786 elif ssl_error
.reason
== "WRONG_VERSION_NUMBER":
788 "Execution environment doesn't support TLS, primitives cannot be executed"
795 def _write_op_detailed_status(self
, db_dict
, status
, detailed_message
):
796 # write ee_id to database: _admin.deployed.VCA.x
798 the_table
= db_dict
["collection"]
799 the_filter
= db_dict
["filter"]
800 update_dict
= {"detailed-status": "{}: {}".format(status
, detailed_message
)}
801 # self.log.debug('Writing ee_id to database: {}'.format(the_path))
805 update_dict
=update_dict
,
808 except asyncio
.CancelledError
:
810 except Exception as e
:
811 self
.log
.error("Error writing detailedStatus to database: {}".format(e
))
813 async def _get_system_cluster_id(self
):
814 if not self
._system
_cluster
_id
:
815 db_k8cluster
= self
.db
.get_one(
816 "k8sclusters", {"name": self
.vca_config
.kubectl_osm_cluster_name
}
818 k8s_hc_id
= deep_get(db_k8cluster
, ("_admin", "helm-chart-v3", "id"))
821 # backward compatibility for existing clusters that have not been initialized for helm v3
822 cluster_id
= db_k8cluster
.get("_id")
823 k8s_credentials
= yaml
.safe_dump(db_k8cluster
.get("credentials"))
824 k8s_hc_id
, uninstall_sw
= await self
._k
8sclusterhelm
3.init_env(
825 k8s_credentials
, reuse_cluster_uuid
=cluster_id
827 db_k8scluster_update
= {
828 "_admin.helm-chart-v3.error_msg": None,
829 "_admin.helm-chart-v3.id": k8s_hc_id
,
830 "_admin.helm-chart-v3}.created": uninstall_sw
,
831 "_admin.helm-chart-v3.operationalState": "ENABLED",
833 self
.update_db_2("k8sclusters", cluster_id
, db_k8scluster_update
)
834 except Exception as e
:
836 "error initializing helm-v3 cluster: {}".format(str(e
))
839 "K8s system cluster '{}' has not been initialized for helm-chart-v3".format(
843 self
._system
_cluster
_id
= k8s_hc_id
844 return self
._system
_cluster
_id