1 # Copyright 2020 Canonical Ltd.
3 # Licensed under the Apache License, Version 2.0 (the "License");
4 # you may not use this file except in compliance with the License.
5 # You may obtain a copy of the License at
7 # http://www.apache.org/licenses/LICENSE-2.0
9 # Unless required by applicable law or agreed to in writing, software
10 # distributed under the License is distributed on an "AS IS" BASIS,
11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 # See the License for the specific language governing permissions and
13 # limitations under the License.
22 from juju
.model
import Model
23 from juju
.machine
import Machine
24 from juju
.application
import Application
25 from juju
.unit
import Unit
26 from juju
.client
._definitions
import (
28 QueryApplicationOffersResults
,
32 from juju
.controller
import Controller
33 from juju
.client
import client
36 from n2vc
.definitions
import Offer
, RelationEndpoint
37 from n2vc
.juju_watcher
import JujuModelWatcher
38 from n2vc
.provisioner
import AsyncSSHProvisioner
39 from n2vc
.n2vc_conn
import N2VCConnector
40 from n2vc
.exceptions
import (
42 JujuApplicationNotFound
,
43 JujuLeaderUnitNotFound
,
45 JujuControllerFailedConnecting
,
46 JujuApplicationExists
,
47 JujuInvalidK8sConfiguration
,
50 from n2vc
.vca
.cloud
import Cloud
as VcaCloud
51 from n2vc
.vca
.connection
import Connection
52 from kubernetes
.client
.configuration
import Configuration
53 from retrying_async
import retry
56 RBAC_LABEL_KEY_NAME
= "rbac-id"
62 vca_connection
: Connection
,
63 loop
: asyncio
.AbstractEventLoop
= None,
64 log
: logging
.Logger
= None,
65 n2vc
: N2VCConnector
= None,
70 :param: vca_connection: n2vc.vca.connection object
71 :param: loop: Asyncio loop
73 :param: n2vc: N2VC object
76 self
.log
= log
or logging
.getLogger("Libjuju")
78 self
.vca_connection
= vca_connection
80 self
.loop
= loop
or asyncio
.get_event_loop()
81 self
.loop
.set_exception_handler(self
.handle_exception
)
82 self
.creating_model
= asyncio
.Lock(loop
=self
.loop
)
84 if self
.vca_connection
.is_default
:
85 self
.health_check_task
= self
._create
_health
_check
_task
()
87 def _create_health_check_task(self
):
88 return self
.loop
.create_task(self
.health_check())
90 async def get_controller(self
, timeout
: float = 60.0) -> Controller
:
94 :param: timeout: Time in seconds to wait for controller to connect
98 controller
= Controller()
99 await asyncio
.wait_for(
101 endpoint
=self
.vca_connection
.data
.endpoints
,
102 username
=self
.vca_connection
.data
.user
,
103 password
=self
.vca_connection
.data
.secret
,
104 cacert
=self
.vca_connection
.data
.cacert
,
108 if self
.vca_connection
.is_default
:
109 endpoints
= await controller
.api_endpoints
111 endpoint
in self
.vca_connection
.endpoints
for endpoint
in endpoints
113 await self
.vca_connection
.update_endpoints(endpoints
)
115 except asyncio
.CancelledError
as e
:
117 except Exception as e
:
119 "Failed connecting to controller: {}... {}".format(
120 self
.vca_connection
.data
.endpoints
, e
124 await self
.disconnect_controller(controller
)
126 raise JujuControllerFailedConnecting(
127 f
"Error connecting to Juju controller: {e}"
130 async def disconnect(self
):
132 # Cancel health check task
133 self
.health_check_task
.cancel()
134 self
.log
.debug("Libjuju disconnected!")
136 async def disconnect_model(self
, model
: Model
):
140 :param: model: Model that will be disconnected
142 await model
.disconnect()
144 async def disconnect_controller(self
, controller
: Controller
):
146 Disconnect controller
148 :param: controller: Controller that will be disconnected
151 await controller
.disconnect()
153 @retry(attempts
=3, delay
=5, timeout
=None)
154 async def add_model(self
, model_name
: str, cloud
: VcaCloud
):
158 :param: model_name: Model name
159 :param: cloud: Cloud object
163 controller
= await self
.get_controller()
166 # Block until other workers have finished model creation
167 while self
.creating_model
.locked():
168 await asyncio
.sleep(0.1)
171 async with self
.creating_model
:
172 if await self
.model_exists(model_name
, controller
=controller
):
174 self
.log
.debug("Creating model {}".format(model_name
))
175 model
= await controller
.add_model(
177 config
=self
.vca_connection
.data
.model_config
,
178 cloud_name
=cloud
.name
,
179 credential_name
=cloud
.credential_name
,
181 except juju
.errors
.JujuAPIError
as e
:
182 if "already exists" in e
.message
:
188 await self
.disconnect_model(model
)
189 await self
.disconnect_controller(controller
)
191 async def get_executed_actions(self
, model_name
: str) -> list:
193 Get executed/history of actions for a model.
195 :param: model_name: Model name, str.
196 :return: List of executed actions for a model.
199 executed_actions
= []
200 controller
= await self
.get_controller()
202 model
= await self
.get_model(controller
, model_name
)
203 # Get all unique action names
205 for application
in model
.applications
:
206 application_actions
= await self
.get_actions(application
, model_name
)
207 actions
.update(application_actions
)
208 # Get status of all actions
209 for application_action
in actions
:
210 app_action_status_list
= await model
.get_action_status(
211 name
=application_action
213 for action_id
, action_status
in app_action_status_list
.items():
216 "action": application_action
,
217 "status": action_status
,
219 # Get action output by id
220 action_status
= await model
.get_action_output(executed_action
["id"])
221 for k
, v
in action_status
.items():
222 executed_action
[k
] = v
223 executed_actions
.append(executed_action
)
224 except Exception as e
:
226 "Error in getting executed actions for model: {}. Error: {}".format(
232 await self
.disconnect_model(model
)
233 await self
.disconnect_controller(controller
)
234 return executed_actions
236 async def get_application_configs(
237 self
, model_name
: str, application_name
: str
240 Get available configs for an application.
242 :param: model_name: Model name, str.
243 :param: application_name: Application name, str.
245 :return: A dict which has key - action name, value - action description
248 application_configs
= {}
249 controller
= await self
.get_controller()
251 model
= await self
.get_model(controller
, model_name
)
252 application
= self
._get
_application
(
253 model
, application_name
=application_name
255 application_configs
= await application
.get_config()
256 except Exception as e
:
258 "Error in getting configs for application: {} in model: {}. Error: {}".format(
259 application_name
, model_name
, str(e
)
264 await self
.disconnect_model(model
)
265 await self
.disconnect_controller(controller
)
266 return application_configs
268 @retry(attempts
=3, delay
=5)
269 async def get_model(self
, controller
: Controller
, model_name
: str) -> Model
:
271 Get model from controller
273 :param: controller: Controller
274 :param: model_name: Model name
276 :return: Model: The created Juju model object
278 return await controller
.get_model(model_name
)
280 async def model_exists(
281 self
, model_name
: str, controller
: Controller
= None
284 Check if model exists
286 :param: controller: Controller
287 :param: model_name: Model name
291 need_to_disconnect
= False
293 # Get controller if not passed
295 controller
= await self
.get_controller()
296 need_to_disconnect
= True
298 # Check if model exists
300 return model_name
in await controller
.list_models()
302 if need_to_disconnect
:
303 await self
.disconnect_controller(controller
)
305 async def models_exist(self
, model_names
: [str]) -> (bool, list):
307 Check if models exists
309 :param: model_names: List of strings with model names
311 :return (bool, list[str]): (True if all models exists, List of model names that don't exist)
315 "model_names must be a non-empty array. Given value: {}".format(
319 non_existing_models
= []
320 models
= await self
.list_models()
321 existing_models
= list(set(models
).intersection(model_names
))
322 non_existing_models
= list(set(model_names
) - set(existing_models
))
325 len(non_existing_models
) == 0,
329 async def get_model_status(self
, model_name
: str) -> FullStatus
:
333 :param: model_name: Model name
335 :return: Full status object
337 controller
= await self
.get_controller()
338 model
= await self
.get_model(controller
, model_name
)
340 return await model
.get_status()
342 await self
.disconnect_model(model
)
343 await self
.disconnect_controller(controller
)
345 async def create_machine(
348 machine_id
: str = None,
349 db_dict
: dict = None,
350 progress_timeout
: float = None,
351 total_timeout
: float = None,
352 series
: str = "bionic",
354 ) -> (Machine
, bool):
358 :param: model_name: Model name
359 :param: machine_id: Machine id
360 :param: db_dict: Dictionary with data of the DB to write the updates
361 :param: progress_timeout: Maximum time between two updates in the model
362 :param: total_timeout: Timeout for the entity to be active
363 :param: series: Series of the machine (xenial, bionic, focal, ...)
364 :param: wait: Wait until machine is ready
366 :return: (juju.machine.Machine, bool): Machine object and a boolean saying
367 if the machine is new or it already existed
373 "Creating machine (id={}) in model: {}".format(machine_id
, model_name
)
377 controller
= await self
.get_controller()
380 model
= await self
.get_model(controller
, model_name
)
382 if machine_id
is not None:
384 "Searching machine (id={}) in model {}".format(
385 machine_id
, model_name
389 # Get machines from model and get the machine with machine_id if exists
390 machines
= await model
.get_machines()
391 if machine_id
in machines
:
393 "Machine (id={}) found in model {}".format(
394 machine_id
, model_name
397 machine
= machines
[machine_id
]
399 raise JujuMachineNotFound("Machine {} not found".format(machine_id
))
402 self
.log
.debug("Creating a new machine in model {}".format(model_name
))
405 machine
= await model
.add_machine(
406 spec
=None, constraints
=None, disks
=None, series
=series
410 # Wait until the machine is ready
412 "Wait until machine {} is ready in model {}".format(
413 machine
.entity_id
, model_name
417 await JujuModelWatcher
.wait_for(
420 progress_timeout
=progress_timeout
,
421 total_timeout
=total_timeout
,
424 vca_id
=self
.vca_connection
._vca
_id
,
427 await self
.disconnect_model(model
)
428 await self
.disconnect_controller(controller
)
431 "Machine {} ready at {} in model {}".format(
432 machine
.entity_id
, machine
.dns_name
, model_name
437 async def provision_machine(
442 private_key_path
: str,
443 db_dict
: dict = None,
444 progress_timeout
: float = None,
445 total_timeout
: float = None,
448 Manually provisioning of a machine
450 :param: model_name: Model name
451 :param: hostname: IP to access the machine
452 :param: username: Username to login to the machine
453 :param: private_key_path: Local path for the private key
454 :param: db_dict: Dictionary with data of the DB to write the updates
455 :param: progress_timeout: Maximum time between two updates in the model
456 :param: total_timeout: Timeout for the entity to be active
458 :return: (Entity): Machine id
461 "Provisioning machine. model: {}, hostname: {}, username: {}".format(
462 model_name
, hostname
, username
467 controller
= await self
.get_controller()
470 model
= await self
.get_model(controller
, model_name
)
474 provisioner
= AsyncSSHProvisioner(
477 private_key_path
=private_key_path
,
482 params
= await provisioner
.provision_machine()
484 params
.jobs
= ["JobHostUnits"]
486 self
.log
.debug("Adding machine to model")
487 connection
= model
.connection()
488 client_facade
= client
.ClientFacade
.from_connection(connection
)
490 results
= await client_facade
.AddMachines(params
=[params
])
491 error
= results
.machines
[0].error
494 msg
= "Error adding machine: {}".format(error
.message
)
495 self
.log
.error(msg
=msg
)
496 raise ValueError(msg
)
498 machine_id
= results
.machines
[0].machine
500 self
.log
.debug("Installing Juju agent into machine {}".format(machine_id
))
501 asyncio
.ensure_future(
502 provisioner
.install_agent(
503 connection
=connection
,
505 machine_id
=machine_id
,
506 proxy
=self
.vca_connection
.data
.api_proxy
,
507 series
=params
.series
,
513 machine_list
= await model
.get_machines()
514 if machine_id
in machine_list
:
515 self
.log
.debug("Machine {} found in model!".format(machine_id
))
516 machine
= model
.machines
.get(machine_id
)
518 await asyncio
.sleep(2)
521 msg
= "Machine {} not found in model".format(machine_id
)
522 self
.log
.error(msg
=msg
)
523 raise JujuMachineNotFound(msg
)
526 "Wait until machine {} is ready in model {}".format(
527 machine
.entity_id
, model_name
530 await JujuModelWatcher
.wait_for(
533 progress_timeout
=progress_timeout
,
534 total_timeout
=total_timeout
,
537 vca_id
=self
.vca_connection
._vca
_id
,
539 except Exception as e
:
542 await self
.disconnect_model(model
)
543 await self
.disconnect_controller(controller
)
546 "Machine provisioned {} in model {}".format(machine_id
, model_name
)
552 self
, uri
: str, model_name
: str, wait
: bool = True, timeout
: float = 3600
555 Deploy bundle or charm: Similar to the juju CLI command `juju deploy`
557 :param: uri: Path or Charm Store uri in which the charm or bundle can be found
558 :param: model_name: Model name
559 :param: wait: Indicates whether to wait or not until all applications are active
560 :param: timeout: Time in seconds to wait until all applications are active
562 controller
= await self
.get_controller()
563 model
= await self
.get_model(controller
, model_name
)
565 await model
.deploy(uri
, trust
=True)
567 await JujuModelWatcher
.wait_for_model(model
, timeout
=timeout
)
568 self
.log
.debug("All units active in model {}".format(model_name
))
570 await self
.disconnect_model(model
)
571 await self
.disconnect_controller(controller
)
575 application_name
: str,
578 db_dict
: dict = None,
579 progress_timeout
: float = None,
580 total_timeout
: float = None,
584 :param: application_name: Application name
585 :param: model_name: Model name
586 :param: machine_id Machine id
587 :param: db_dict: Dictionary with data of the DB to write the updates
588 :param: progress_timeout: Maximum time between two updates in the model
589 :param: total_timeout: Timeout for the entity to be active
595 controller
= await self
.get_controller()
597 model
= await self
.get_model(controller
, model_name
)
598 application
= self
._get
_application
(model
, application_name
)
600 if application
is not None:
602 # Checks if the given machine id in the model,
603 # otherwise function raises an error
604 _machine
, _series
= self
._get
_machine
_info
(model
, machine_id
)
607 "Adding unit (machine {}) to application {} in model ~{}".format(
608 machine_id
, application_name
, model_name
612 await application
.add_unit(to
=machine_id
)
614 await JujuModelWatcher
.wait_for(
617 progress_timeout
=progress_timeout
,
618 total_timeout
=total_timeout
,
621 vca_id
=self
.vca_connection
._vca
_id
,
624 "Unit is added to application {} in model {}".format(
625 application_name
, model_name
629 raise JujuApplicationNotFound(
630 "Application {} not exists".format(application_name
)
634 await self
.disconnect_model(model
)
635 await self
.disconnect_controller(controller
)
637 async def destroy_unit(
639 application_name
: str,
642 total_timeout
: float = None,
646 :param: application_name: Application name
647 :param: model_name: Model name
648 :param: machine_id Machine id
649 :param: total_timeout: Timeout for the entity to be active
655 controller
= await self
.get_controller()
657 model
= await self
.get_model(controller
, model_name
)
658 application
= self
._get
_application
(model
, application_name
)
660 if application
is None:
661 raise JujuApplicationNotFound(
662 "Application not found: {} (model={})".format(
663 application_name
, model_name
667 unit
= self
._get
_unit
(application
, machine_id
)
670 "A unit with machine id {} not in available units".format(
675 unit_name
= unit
.name
678 "Destroying unit {} from application {} in model {}".format(
679 unit_name
, application_name
, model_name
682 await application
.destroy_unit(unit_name
)
685 "Waiting for unit {} to be destroyed in application {} (model={})...".format(
686 unit_name
, application_name
, model_name
690 # TODO: Add functionality in the Juju watcher to replace this kind of blocks
691 if total_timeout
is None:
693 end
= time
.time() + total_timeout
694 while time
.time() < end
:
695 if not self
._get
_unit
(application
, machine_id
):
697 "The unit {} was destroyed in application {} (model={}) ".format(
698 unit_name
, application_name
, model_name
702 await asyncio
.sleep(5)
704 "Unit {} is destroyed from application {} in model {}".format(
705 unit_name
, application_name
, model_name
710 await self
.disconnect_model(model
)
711 await self
.disconnect_controller(controller
)
713 async def deploy_charm(
715 application_name
: str,
719 db_dict
: dict = None,
720 progress_timeout
: float = None,
721 total_timeout
: float = None,
728 :param: application_name: Application name
729 :param: path: Local path to the charm
730 :param: model_name: Model name
731 :param: machine_id ID of the machine
732 :param: db_dict: Dictionary with data of the DB to write the updates
733 :param: progress_timeout: Maximum time between two updates in the model
734 :param: total_timeout: Timeout for the entity to be active
735 :param: config: Config for the charm
736 :param: series: Series of the charm
737 :param: num_units: Number of units
739 :return: (juju.application.Application): Juju application
742 "Deploying charm {} to machine {} in model ~{}".format(
743 application_name
, machine_id
, model_name
746 self
.log
.debug("charm: {}".format(path
))
749 controller
= await self
.get_controller()
752 model
= await self
.get_model(controller
, model_name
)
755 if application_name
not in model
.applications
:
757 if machine_id
is not None:
758 machine
, series
= self
._get
_machine
_info
(model
, machine_id
)
760 application
= await model
.deploy(
762 application_name
=application_name
,
771 "Wait until application {} is ready in model {}".format(
772 application_name
, model_name
776 for _
in range(num_units
- 1):
777 m
, _
= await self
.create_machine(model_name
, wait
=False)
778 await application
.add_unit(to
=m
.entity_id
)
780 await JujuModelWatcher
.wait_for(
783 progress_timeout
=progress_timeout
,
784 total_timeout
=total_timeout
,
787 vca_id
=self
.vca_connection
._vca
_id
,
790 "Application {} is ready in model {}".format(
791 application_name
, model_name
795 raise JujuApplicationExists(
796 "Application {} exists".format(application_name
)
798 except juju
.errors
.JujuError
as e
:
799 if "already exists" in e
.message
:
800 raise JujuApplicationExists(
801 "Application {} exists".format(application_name
)
806 await self
.disconnect_model(model
)
807 await self
.disconnect_controller(controller
)
811 async def resolve(self
, model_name
: str):
813 controller
= await self
.get_controller()
814 model
= await self
.get_model(controller
, model_name
)
815 all_units_active
= False
817 while not all_units_active
:
818 all_units_active
= True
819 for application_name
, application
in model
.applications
.items():
820 if application
.status
== "error":
821 for unit
in application
.units
:
822 if unit
.workload_status
== "error":
824 "Model {}, Application {}, Unit {} in error state, resolving".format(
825 model_name
, application_name
, unit
.entity_id
829 await unit
.resolved(retry
=False)
830 all_units_active
= False
834 if not all_units_active
:
835 await asyncio
.sleep(5)
837 await self
.disconnect_model(model
)
838 await self
.disconnect_controller(controller
)
840 async def scale_application(
843 application_name
: str,
845 total_timeout
: float = None,
848 Scale application (K8s)
850 :param: model_name: Model name
851 :param: application_name: Application name
852 :param: scale: Scale to which to set this application
853 :param: total_timeout: Timeout for the entity to be active
857 controller
= await self
.get_controller()
859 model
= await self
.get_model(controller
, model_name
)
862 "Scaling application {} in model {}".format(
863 application_name
, model_name
866 application
= self
._get
_application
(model
, application_name
)
867 if application
is None:
868 raise JujuApplicationNotFound("Cannot scale application")
869 await application
.scale(scale
=scale
)
870 # Wait until application is scaled in model
872 "Waiting for application {} to be scaled in model {}...".format(
873 application_name
, model_name
876 if total_timeout
is None:
878 end
= time
.time() + total_timeout
879 while time
.time() < end
:
880 application_scale
= self
._get
_application
_count
(model
, application_name
)
881 # Before calling wait_for_model function,
882 # wait until application unit count and scale count are equal.
883 # Because there is a delay before scaling triggers in Juju model.
884 if application_scale
== scale
:
885 await JujuModelWatcher
.wait_for_model(
886 model
=model
, timeout
=total_timeout
889 "Application {} is scaled in model {}".format(
890 application_name
, model_name
894 await asyncio
.sleep(5)
896 "Timeout waiting for application {} in model {} to be scaled".format(
897 application_name
, model_name
902 await self
.disconnect_model(model
)
903 await self
.disconnect_controller(controller
)
905 def _get_application_count(self
, model
: Model
, application_name
: str) -> int:
906 """Get number of units of the application
908 :param: model: Model object
909 :param: application_name: Application name
911 :return: int (or None if application doesn't exist)
913 application
= self
._get
_application
(model
, application_name
)
914 if application
is not None:
915 return len(application
.units
)
917 def _get_application(self
, model
: Model
, application_name
: str) -> Application
:
920 :param: model: Model object
921 :param: application_name: Application name
923 :return: juju.application.Application (or None if it doesn't exist)
925 if model
.applications
and application_name
in model
.applications
:
926 return model
.applications
[application_name
]
928 def _get_unit(self
, application
: Application
, machine_id
: str) -> Unit
:
931 :param: application: Application object
932 :param: machine_id: Machine id
937 for u
in application
.units
:
938 if u
.machine_id
== machine_id
:
943 def _get_machine_info(
950 :param: model: Model object
951 :param: machine_id: Machine id
953 :return: (str, str): (machine, series)
955 if machine_id
not in model
.machines
:
956 msg
= "Machine {} not found in model".format(machine_id
)
957 self
.log
.error(msg
=msg
)
958 raise JujuMachineNotFound(msg
)
959 machine
= model
.machines
[machine_id
]
960 return machine
, machine
.series
962 async def execute_action(
964 application_name
: str,
967 db_dict
: dict = None,
968 machine_id
: str = None,
969 progress_timeout
: float = None,
970 total_timeout
: float = None,
975 :param: application_name: Application name
976 :param: model_name: Model name
977 :param: action_name: Name of the action
978 :param: db_dict: Dictionary with data of the DB to write the updates
979 :param: machine_id Machine id
980 :param: progress_timeout: Maximum time between two updates in the model
981 :param: total_timeout: Timeout for the entity to be active
983 :return: (str, str): (output and status)
986 "Executing action {} using params {}".format(action_name
, kwargs
)
989 controller
= await self
.get_controller()
992 model
= await self
.get_model(controller
, model_name
)
996 application
= self
._get
_application
(
998 application_name
=application_name
,
1000 if application
is None:
1001 raise JujuApplicationNotFound("Cannot execute action")
1003 # Ocassionally, self._get_leader_unit() will return None
1004 # because the leader elected hook has not been triggered yet.
1005 # Therefore, we are doing some retries. If it happens again,
1007 if machine_id
is None:
1008 unit
= await self
._get
_leader
_unit
(application
)
1010 "Action {} is being executed on the leader unit {}".format(
1011 action_name
, unit
.name
1015 unit
= self
._get
_unit
(application
, machine_id
)
1018 "A unit with machine id {} not in available units".format(
1023 "Action {} is being executed on {} unit".format(
1024 action_name
, unit
.name
1028 actions
= await application
.get_actions()
1030 if action_name
not in actions
:
1031 raise JujuActionNotFound(
1032 "Action {} not in available actions".format(action_name
)
1035 action
= await unit
.run_action(action_name
, **kwargs
)
1038 "Wait until action {} is completed in application {} (model={})".format(
1039 action_name
, application_name
, model_name
1042 await JujuModelWatcher
.wait_for(
1045 progress_timeout
=progress_timeout
,
1046 total_timeout
=total_timeout
,
1049 vca_id
=self
.vca_connection
._vca
_id
,
1052 output
= await model
.get_action_output(action_uuid
=action
.entity_id
)
1053 status
= await model
.get_action_status(uuid_or_prefix
=action
.entity_id
)
1055 status
[action
.entity_id
] if action
.entity_id
in status
else "failed"
1059 "Action {} completed with status {} in application {} (model={})".format(
1060 action_name
, action
.status
, application_name
, model_name
1064 await self
.disconnect_model(model
)
1065 await self
.disconnect_controller(controller
)
1067 return output
, status
1069 async def get_actions(self
, application_name
: str, model_name
: str) -> dict:
1070 """Get list of actions
1072 :param: application_name: Application name
1073 :param: model_name: Model name
1075 :return: Dict with this format
1077 "action_name": "Description of the action",
1082 "Getting list of actions for application {}".format(application_name
)
1086 controller
= await self
.get_controller()
1089 model
= await self
.get_model(controller
, model_name
)
1093 application
= self
._get
_application
(
1095 application_name
=application_name
,
1098 # Return list of actions
1099 return await application
.get_actions()
1102 # Disconnect from model and controller
1103 await self
.disconnect_model(model
)
1104 await self
.disconnect_controller(controller
)
1106 async def get_metrics(self
, model_name
: str, application_name
: str) -> dict:
1107 """Get the metrics collected by the VCA.
1109 :param model_name The name or unique id of the network service
1110 :param application_name The name of the application
1112 if not model_name
or not application_name
:
1113 raise Exception("model_name and application_name must be non-empty strings")
1115 controller
= await self
.get_controller()
1116 model
= await self
.get_model(controller
, model_name
)
1118 application
= self
._get
_application
(model
, application_name
)
1119 if application
is not None:
1120 metrics
= await application
.get_metrics()
1122 self
.disconnect_model(model
)
1123 self
.disconnect_controller(controller
)
1126 async def add_relation(
1134 :param: model_name: Model name
1135 :param: endpoint_1 First endpoint name
1136 ("app:endpoint" format or directly the saas name)
1137 :param: endpoint_2: Second endpoint name (^ same format)
1140 self
.log
.debug("Adding relation: {} -> {}".format(endpoint_1
, endpoint_2
))
1143 controller
= await self
.get_controller()
1146 model
= await self
.get_model(controller
, model_name
)
1150 await model
.add_relation(endpoint_1
, endpoint_2
)
1151 except juju
.errors
.JujuAPIError
as e
:
1152 if "not found" in e
.message
:
1153 self
.log
.warning("Relation not found: {}".format(e
.message
))
1155 if "already exists" in e
.message
:
1156 self
.log
.warning("Relation already exists: {}".format(e
.message
))
1158 # another exception, raise it
1161 await self
.disconnect_model(model
)
1162 await self
.disconnect_controller(controller
)
1164 async def offer(self
, endpoint
: RelationEndpoint
) -> Offer
:
1166 Create an offer from a RelationEndpoint
1168 :param: endpoint: Relation endpoint
1170 :return: Offer object
1172 model_name
= endpoint
.model_name
1173 offer_name
= f
"{endpoint.application_name}-{endpoint.endpoint_name}"
1174 controller
= await self
.get_controller()
1177 model
= await self
.get_model(controller
, model_name
)
1178 await model
.create_offer(endpoint
.endpoint
, offer_name
=offer_name
)
1179 offer_list
= await self
._list
_offers
(model_name
, offer_name
=offer_name
)
1181 return Offer(offer_list
[0].offer_url
)
1183 raise Exception("offer was not created")
1184 except juju
.errors
.JujuError
as e
:
1185 if "application offer already exists" not in e
.message
:
1189 self
.disconnect_model(model
)
1190 self
.disconnect_controller(controller
)
1196 provider_libjuju
: "Libjuju",
1199 Consumes a remote offer in the model. Relations can be created later using "juju relate".
1201 :param: model_name: Model name
1202 :param: offer: Offer object to consume
1203 :param: provider_libjuju: Libjuju object of the provider endpoint
1205 :raises ParseError if there's a problem parsing the offer_url
1206 :raises JujuError if remote offer includes and endpoint
1207 :raises JujuAPIError if the operation is not successful
1209 :returns: Saas name. It is the application name in the model that reference the remote application.
1211 saas_name
= f
'{offer.name}-{offer.model_name.replace("-", "")}'
1213 saas_name
= f
"{saas_name}-{offer.vca_id}"
1214 controller
= await self
.get_controller()
1216 provider_controller
= None
1218 model
= await controller
.get_model(model_name
)
1219 provider_controller
= await provider_libjuju
.get_controller()
1220 await model
.consume(
1221 offer
.url
, application_alias
=saas_name
, controller
=provider_controller
1226 await self
.disconnect_model(model
)
1227 if provider_controller
:
1228 await provider_libjuju
.disconnect_controller(provider_controller
)
1229 await self
.disconnect_controller(controller
)
1231 async def destroy_model(self
, model_name
: str, total_timeout
: float = 1800):
1235 :param: model_name: Model name
1236 :param: total_timeout: Timeout
1239 controller
= await self
.get_controller()
1242 if not await self
.model_exists(model_name
, controller
=controller
):
1245 self
.log
.debug("Destroying model {}".format(model_name
))
1247 model
= await self
.get_model(controller
, model_name
)
1248 # Destroy machines that are manually provisioned
1249 # and still are in pending state
1250 await self
._destroy
_pending
_machines
(model
, only_manual
=True)
1251 await self
.disconnect_model(model
)
1253 await asyncio
.wait_for(
1254 self
._destroy
_model
(model_name
, controller
),
1255 timeout
=total_timeout
,
1257 except Exception as e
:
1258 if not await self
.model_exists(model_name
, controller
=controller
):
1263 await self
.disconnect_model(model
)
1264 await self
.disconnect_controller(controller
)
1266 async def _destroy_model(
1269 controller
: Controller
,
1272 Destroy model from controller
1274 :param: model: Model name to be removed
1275 :param: controller: Controller object
1276 :param: timeout: Timeout in seconds
1279 async def _destroy_model_gracefully(model_name
: str, controller
: Controller
):
1280 self
.log
.info(f
"Gracefully deleting model {model_name}")
1282 while model_name
in await controller
.list_models():
1284 await self
.resolve(model_name
)
1286 await controller
.destroy_model(model_name
, destroy_storage
=True)
1288 await asyncio
.sleep(5)
1289 self
.log
.info(f
"Model {model_name} deleted gracefully")
1291 async def _destroy_model_forcefully(model_name
: str, controller
: Controller
):
1292 self
.log
.info(f
"Forcefully deleting model {model_name}")
1293 while model_name
in await controller
.list_models():
1294 await controller
.destroy_model(
1295 model_name
, destroy_storage
=True, force
=True, max_wait
=60
1297 await asyncio
.sleep(5)
1298 self
.log
.info(f
"Model {model_name} deleted forcefully")
1302 await asyncio
.wait_for(
1303 _destroy_model_gracefully(model_name
, controller
), timeout
=120
1305 except asyncio
.TimeoutError
:
1306 await _destroy_model_forcefully(model_name
, controller
)
1307 except juju
.errors
.JujuError
as e
:
1308 if any("has been removed" in error
for error
in e
.errors
):
1310 if any("model not found" in error
for error
in e
.errors
):
1314 async def destroy_application(
1315 self
, model_name
: str, application_name
: str, total_timeout
: float
1320 :param: model_name: Model name
1321 :param: application_name: Application name
1322 :param: total_timeout: Timeout
1325 controller
= await self
.get_controller()
1329 model
= await self
.get_model(controller
, model_name
)
1331 "Destroying application {} in model {}".format(
1332 application_name
, model_name
1335 application
= self
._get
_application
(model
, application_name
)
1337 await application
.destroy()
1339 self
.log
.warning("Application not found: {}".format(application_name
))
1342 "Waiting for application {} to be destroyed in model {}...".format(
1343 application_name
, model_name
1346 if total_timeout
is None:
1347 total_timeout
= 3600
1348 end
= time
.time() + total_timeout
1349 while time
.time() < end
:
1350 if not self
._get
_application
(model
, application_name
):
1352 "The application {} was destroyed in model {} ".format(
1353 application_name
, model_name
1357 await asyncio
.sleep(5)
1359 "Timeout waiting for application {} to be destroyed in model {}".format(
1360 application_name
, model_name
1364 if model
is not None:
1365 await self
.disconnect_model(model
)
1366 await self
.disconnect_controller(controller
)
1368 async def _destroy_pending_machines(self
, model
: Model
, only_manual
: bool = False):
1370 Destroy pending machines in a given model
1372 :param: only_manual: Bool that indicates only manually provisioned
1373 machines should be destroyed (if True), or that
1374 all pending machines should be destroyed
1376 status
= await model
.get_status()
1377 for machine_id
in status
.machines
:
1378 machine_status
= status
.machines
[machine_id
]
1379 if machine_status
.agent_status
.status
== "pending":
1380 if only_manual
and not machine_status
.instance_id
.startswith("manual:"):
1382 machine
= model
.machines
[machine_id
]
1383 await machine
.destroy(force
=True)
1385 async def configure_application(
1386 self
, model_name
: str, application_name
: str, config
: dict = None
1388 """Configure application
1390 :param: model_name: Model name
1391 :param: application_name: Application name
1392 :param: config: Config to apply to the charm
1394 self
.log
.debug("Configuring application {}".format(application_name
))
1397 controller
= await self
.get_controller()
1400 model
= await self
.get_model(controller
, model_name
)
1401 application
= self
._get
_application
(
1403 application_name
=application_name
,
1405 await application
.set_config(config
)
1408 await self
.disconnect_model(model
)
1409 await self
.disconnect_controller(controller
)
1411 def handle_exception(self
, loop
, context
):
1412 # All unhandled exceptions by libjuju are handled here.
1415 async def health_check(self
, interval
: float = 300.0):
1417 Health check to make sure controller and controller_model connections are OK
1419 :param: interval: Time in seconds between checks
1424 controller
= await self
.get_controller()
1425 # self.log.debug("VCA is alive")
1426 except Exception as e
:
1427 self
.log
.error("Health check to VCA failed: {}".format(e
))
1429 await self
.disconnect_controller(controller
)
1430 await asyncio
.sleep(interval
)
1432 async def list_models(self
, contains
: str = None) -> [str]:
1433 """List models with certain names
1435 :param: contains: String that is contained in model name
1437 :retur: [models] Returns list of model names
1440 controller
= await self
.get_controller()
1442 models
= await controller
.list_models()
1444 models
= [model
for model
in models
if contains
in model
]
1447 await self
.disconnect_controller(controller
)
1449 async def _list_offers(
1450 self
, model_name
: str, offer_name
: str = None
1451 ) -> QueryApplicationOffersResults
:
1453 List offers within a model
1455 :param: model_name: Model name
1456 :param: offer_name: Offer name to filter.
1458 :return: Returns application offers results in the model
1461 controller
= await self
.get_controller()
1463 offers
= (await controller
.list_offers(model_name
)).results
1466 for offer
in offers
:
1467 if offer
.offer_name
== offer_name
:
1468 matching_offer
.append(offer
)
1470 offers
= matching_offer
1473 await self
.disconnect_controller(controller
)
1480 client_cert_data
: str,
1481 configuration
: Configuration
,
1483 credential_name
: str = None,
1486 Add a Kubernetes cloud to the controller
1488 Similar to the `juju add-k8s` command in the CLI
1490 :param: name: Name for the K8s cloud
1491 :param: configuration: Kubernetes configuration object
1492 :param: storage_class: Storage Class to use in the cloud
1493 :param: credential_name: Storage Class to use in the cloud
1496 if not storage_class
:
1497 raise Exception("storage_class must be a non-empty string")
1499 raise Exception("name must be a non-empty string")
1500 if not configuration
:
1501 raise Exception("configuration must be provided")
1503 endpoint
= configuration
.host
1504 credential
= self
.get_k8s_cloud_credential(
1509 credential
.attrs
[RBAC_LABEL_KEY_NAME
] = rbac_id
1510 cloud
= client
.Cloud(
1512 auth_types
=[credential
.auth_type
],
1514 ca_certificates
=[client_cert_data
],
1516 "operator-storage": storage_class
,
1517 "workload-storage": storage_class
,
1521 return await self
.add_cloud(
1522 name
, cloud
, credential
, credential_name
=credential_name
1525 def get_k8s_cloud_credential(
1527 configuration
: Configuration
,
1528 client_cert_data
: str,
1530 ) -> client
.CloudCredential
:
1532 # TODO: Test with AKS
1533 key
= None # open(configuration.key_file, "r").read()
1534 username
= configuration
.username
1535 password
= configuration
.password
1537 if client_cert_data
:
1538 attrs
["ClientCertificateData"] = client_cert_data
1540 attrs
["ClientKeyData"] = key
1542 if username
or password
:
1543 raise JujuInvalidK8sConfiguration("Cannot set both token and user/pass")
1544 attrs
["Token"] = token
1548 auth_type
= "oauth2"
1549 if client_cert_data
:
1550 auth_type
= "oauth2withcert"
1552 raise JujuInvalidK8sConfiguration(
1553 "missing token for auth type {}".format(auth_type
)
1558 "credential for user {} has empty password".format(username
)
1560 attrs
["username"] = username
1561 attrs
["password"] = password
1562 if client_cert_data
:
1563 auth_type
= "userpasswithcert"
1565 auth_type
= "userpass"
1566 elif client_cert_data
and token
:
1567 auth_type
= "certificate"
1569 raise JujuInvalidK8sConfiguration("authentication method not supported")
1570 return client
.CloudCredential(auth_type
=auth_type
, attrs
=attrs
)
1572 async def add_cloud(
1576 credential
: CloudCredential
= None,
1577 credential_name
: str = None,
1580 Add cloud to the controller
1582 :param: name: Name of the cloud to be added
1583 :param: cloud: Cloud object
1584 :param: credential: CloudCredentials object for the cloud
1585 :param: credential_name: Credential name.
1586 If not defined, cloud of the name will be used.
1588 controller
= await self
.get_controller()
1590 _
= await controller
.add_cloud(name
, cloud
)
1592 await controller
.add_credential(
1593 credential_name
or name
, credential
=credential
, cloud
=name
1595 # Need to return the object returned by the controller.add_cloud() function
1596 # I'm returning the original value now until this bug is fixed:
1597 # https://github.com/juju/python-libjuju/issues/443
1600 await self
.disconnect_controller(controller
)
1602 async def remove_cloud(self
, name
: str):
1606 :param: name: Name of the cloud to be removed
1608 controller
= await self
.get_controller()
1610 await controller
.remove_cloud(name
)
1611 except juju
.errors
.JujuError
as e
:
1612 if len(e
.errors
) == 1 and f
'cloud "{name}" not found' == e
.errors
[0]:
1613 self
.log
.warning(f
"Cloud {name} not found, so it could not be deleted.")
1617 await self
.disconnect_controller(controller
)
1619 @retry(attempts
=20, delay
=5, fallback
=JujuLeaderUnitNotFound())
1620 async def _get_leader_unit(self
, application
: Application
) -> Unit
:
1622 for u
in application
.units
:
1623 if await u
.is_leader_from_status():
1630 async def get_cloud_credentials(self
, cloud
: Cloud
) -> typing
.List
:
1632 Get cloud credentials
1634 :param: cloud: Cloud object. The returned credentials will be from this cloud.
1636 :return: List of credentials object associated to the specified cloud
1639 controller
= await self
.get_controller()
1641 facade
= client
.CloudFacade
.from_connection(controller
.connection())
1642 cloud_cred_tag
= tag
.credential(
1643 cloud
.name
, self
.vca_connection
.data
.user
, cloud
.credential_name
1645 params
= [client
.Entity(cloud_cred_tag
)]
1646 return (await facade
.Credential(params
)).results
1648 await self
.disconnect_controller(controller
)
1650 async def check_application_exists(self
, model_name
, application_name
) -> bool:
1651 """Check application exists
1653 :param: model_name: Model Name
1654 :param: application_name: Application Name
1660 controller
= await self
.get_controller()
1662 model
= await self
.get_model(controller
, model_name
)
1664 "Checking if application {} exists in model {}".format(
1665 application_name
, model_name
1668 return self
._get
_application
(model
, application_name
) is not None
1671 await self
.disconnect_model(model
)
1672 await self
.disconnect_controller(controller
)