From 30d8e41085621fbdf305c072565c7a56175605c3 Mon Sep 17 00:00:00 2001 From: aticig Date: Tue, 28 Jun 2022 01:56:51 +0300 Subject: [PATCH] LCM sidecar charm Change-Id: Ic03f8a94b8edcfc67aebddfcc27022a130ce8a1b Signed-off-by: David Garcia --- installers/charm/osm-lcm/.gitignore | 29 + installers/charm/osm-lcm/.jujuignore | 23 + installers/charm/osm-lcm/CONTRIBUTING.md | 78 +++ installers/charm/osm-lcm/LICENSE | 202 +++++++ installers/charm/osm-lcm/README.md | 43 ++ installers/charm/osm-lcm/actions.yaml | 26 + installers/charm/osm-lcm/charmcraft.yaml | 36 ++ installers/charm/osm-lcm/config.yaml | 104 ++++ .../charm/osm-lcm/files/vscode-workspace.json | 20 + .../osm-lcm/lib/charms/kafka_k8s/v0/kafka.py | 200 +++++++ .../osm-lcm/lib/charms/osm_libs/v0/utils.py | 518 ++++++++++++++++++ .../charm/osm-lcm/lib/charms/osm_ro/v0/ro.py | 178 ++++++ .../lib/charms/osm_vca_integrator/v0/vca.py | 221 ++++++++ installers/charm/osm-lcm/metadata.yaml | 66 +++ installers/charm/osm-lcm/pyproject.toml | 56 ++ installers/charm/osm-lcm/requirements.txt | 23 + installers/charm/osm-lcm/src/charm.py | 279 ++++++++++ .../charm/osm-lcm/src/legacy_interfaces.py | 107 ++++ .../charm/osm-lcm/tests/unit/test_charm.py | 85 +++ installers/charm/osm-lcm/tox.ini | 92 ++++ 20 files changed, 2386 insertions(+) create mode 100644 installers/charm/osm-lcm/.gitignore create mode 100644 installers/charm/osm-lcm/.jujuignore create mode 100644 installers/charm/osm-lcm/CONTRIBUTING.md create mode 100644 installers/charm/osm-lcm/LICENSE create mode 100644 installers/charm/osm-lcm/README.md create mode 100644 installers/charm/osm-lcm/actions.yaml create mode 100644 installers/charm/osm-lcm/charmcraft.yaml create mode 100644 installers/charm/osm-lcm/config.yaml create mode 100644 installers/charm/osm-lcm/files/vscode-workspace.json create mode 100644 installers/charm/osm-lcm/lib/charms/kafka_k8s/v0/kafka.py create mode 100644 installers/charm/osm-lcm/lib/charms/osm_libs/v0/utils.py create mode 100644 installers/charm/osm-lcm/lib/charms/osm_ro/v0/ro.py create mode 100644 installers/charm/osm-lcm/lib/charms/osm_vca_integrator/v0/vca.py create mode 100644 installers/charm/osm-lcm/metadata.yaml create mode 100644 installers/charm/osm-lcm/pyproject.toml create mode 100644 installers/charm/osm-lcm/requirements.txt create mode 100755 installers/charm/osm-lcm/src/charm.py create mode 100644 installers/charm/osm-lcm/src/legacy_interfaces.py create mode 100644 installers/charm/osm-lcm/tests/unit/test_charm.py create mode 100644 installers/charm/osm-lcm/tox.ini diff --git a/installers/charm/osm-lcm/.gitignore b/installers/charm/osm-lcm/.gitignore new file mode 100644 index 00000000..87d0a587 --- /dev/null +++ b/installers/charm/osm-lcm/.gitignore @@ -0,0 +1,29 @@ +#!/usr/bin/env python3 +# Copyright 2022 Canonical Ltd. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. +# +# For those usages not covered by the Apache License, Version 2.0 please +# contact: legal@canonical.com +# +# To get in touch with the maintainers, please contact: +# osm-charmers@lists.launchpad.net +venv/ +build/ +*.charm +.tox/ +.coverage +coverage.xml +__pycache__/ +*.py[cod] +.vscode \ No newline at end of file diff --git a/installers/charm/osm-lcm/.jujuignore b/installers/charm/osm-lcm/.jujuignore new file mode 100644 index 00000000..17c7a8bb --- /dev/null +++ b/installers/charm/osm-lcm/.jujuignore @@ -0,0 +1,23 @@ +#!/usr/bin/env python3 +# Copyright 2022 Canonical Ltd. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. +# +# For those usages not covered by the Apache License, Version 2.0 please +# contact: legal@canonical.com +# +# To get in touch with the maintainers, please contact: +# osm-charmers@lists.launchpad.net +/venv +*.py[cod] +*.charm diff --git a/installers/charm/osm-lcm/CONTRIBUTING.md b/installers/charm/osm-lcm/CONTRIBUTING.md new file mode 100644 index 00000000..28c9c896 --- /dev/null +++ b/installers/charm/osm-lcm/CONTRIBUTING.md @@ -0,0 +1,78 @@ + + +# Contributing + +## Overview + +This documents explains the processes and practices recommended for contributing enhancements to +this operator. + +- Generally, before developing enhancements to this charm, you should consider [opening an issue + ](https://osm.etsi.org/bugzilla/enter_bug.cgi?product=OSM) explaining your use case. (Component=devops, version=master) +- If you would like to chat with us about your use-cases or proposed implementation, you can reach + us at [OSM Juju public channel](https://opensourcemano.slack.com/archives/C027KJGPECA). +- Familiarising yourself with the [Charmed Operator Framework](https://juju.is/docs/sdk) library + will help you a lot when working on new features or bug fixes. +- All enhancements require review before being merged. Code review typically examines + - code quality + - test coverage + - user experience for Juju administrators this charm. +- Please help us out in ensuring easy to review branches by rebasing your gerrit patch onto + the `master` branch. + +## Developing + +You can use the environments created by `tox` for development: + +```shell +tox --notest -e unit +source .tox/unit/bin/activate +``` + +### Testing + +```shell +tox -e fmt # update your code according to linting rules +tox -e lint # code style +tox -e unit # unit tests +tox -e integration # integration tests +tox # runs 'lint' and 'unit' environments +``` + +## Build charm + +Build the charm in this git repository using: + +```shell +charmcraft pack +``` + +### Deploy + +```bash +# Create a model +juju add-model dev +# Enable DEBUG logging +juju model-config logging-config="=INFO;unit=DEBUG" +# Deploy the charm +juju deploy ./osm-lcm_ubuntu-22.04-amd64.charm \ + --resource lcm-image=opensourcemano/lcm:testing-daily +``` diff --git a/installers/charm/osm-lcm/LICENSE b/installers/charm/osm-lcm/LICENSE new file mode 100644 index 00000000..7e9d5046 --- /dev/null +++ b/installers/charm/osm-lcm/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2022 Canonical Ltd. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/installers/charm/osm-lcm/README.md b/installers/charm/osm-lcm/README.md new file mode 100644 index 00000000..b9b2f80f --- /dev/null +++ b/installers/charm/osm-lcm/README.md @@ -0,0 +1,43 @@ + + + + +# OSM LCM + +Charmhub package name: osm-lcm +More information: https://charmhub.io/osm-lcm + +## Other resources + +* [Read more](https://osm.etsi.org/docs/user-guide/latest/) + +* [Contributing](https://osm.etsi.org/gitweb/?p=osm/devops.git;a=blob;f=installers/charm/osm-lcm/CONTRIBUTING.md) + +* See the [Juju SDK documentation](https://juju.is/docs/sdk) for more information about developing and improving charms. + diff --git a/installers/charm/osm-lcm/actions.yaml b/installers/charm/osm-lcm/actions.yaml new file mode 100644 index 00000000..0d73468f --- /dev/null +++ b/installers/charm/osm-lcm/actions.yaml @@ -0,0 +1,26 @@ +# Copyright 2022 Canonical Ltd. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. +# +# For those usages not covered by the Apache License, Version 2.0 please +# contact: legal@canonical.com +# +# To get in touch with the maintainers, please contact: +# osm-charmers@lists.launchpad.net +# +# +# This file populates the Actions tab on Charmhub. +# See https://juju.is/docs/some-url-to-be-determined/ for a checklist and guidance. + +get-debug-mode-information: + description: Get information to debug the container diff --git a/installers/charm/osm-lcm/charmcraft.yaml b/installers/charm/osm-lcm/charmcraft.yaml new file mode 100644 index 00000000..2932e584 --- /dev/null +++ b/installers/charm/osm-lcm/charmcraft.yaml @@ -0,0 +1,36 @@ +# Copyright 2022 Canonical Ltd. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. +# +# For those usages not covered by the Apache License, Version 2.0 please +# contact: legal@canonical.com +# +# To get in touch with the maintainers, please contact: +# osm-charmers@lists.launchpad.net +# + +type: charm +bases: + - build-on: + - name: "ubuntu" + channel: "22.04" + run-on: + - name: "ubuntu" + channel: "22.04" + +parts: + charm: + # build-packages: + # - git + prime: + - files/* \ No newline at end of file diff --git a/installers/charm/osm-lcm/config.yaml b/installers/charm/osm-lcm/config.yaml new file mode 100644 index 00000000..ac15a0e5 --- /dev/null +++ b/installers/charm/osm-lcm/config.yaml @@ -0,0 +1,104 @@ +# Copyright 2022 Canonical Ltd. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. +# +# For those usages not covered by the Apache License, Version 2.0 please +# contact: legal@canonical.com +# +# To get in touch with the maintainers, please contact: +# osm-charmers@lists.launchpad.net +# +# +# This file populates the Configure tab on Charmhub. +# See https://juju.is/docs/some-url-to-be-determined/ for a checklist and guidance. + +options: + log-level: + default: "INFO" + description: | + Set the Logging Level. + + Options: + - TRACE + - DEBUG + - INFO + - WARN + - ERROR + - FATAL + type: string + database-commonkey: + description: Database COMMON KEY + type: string + default: osm + # Helm options + helm-stable-repo-url: + description: Stable repository URL for Helm charts + type: string + default: https://charts.helm.sh/stable + helm-ca-certs: + description: CA certificates to validate access to Helm repository + type: string + default: "" + # Debug-mode options + debug-mode: + type: boolean + description: | + Great for OSM Developers! (Not recommended for production deployments) + + This action activates the Debug Mode, which sets up the container to be ready for debugging. + As part of the setup, SSH is enabled and a VSCode workspace file is automatically populated. + + After enabling the debug-mode, execute the following command to get the information you need + to start debugging: + `juju run-action get-debug-mode-information --wait` + + The previous command returns the command you need to execute, and the SSH password that was set. + + See also: + - https://charmhub.io/osm-lcm/configure#lcm-hostpath + - https://charmhub.io/osm-lcm/configure#n2vc-hostpath + - https://charmhub.io/osm-lcm/configure#common-hostpath + default: false + lcm-hostpath: + type: string + description: | + Set this config to the local path of the LCM module to persist the changes done during the + debug-mode session. + + Example: + $ git clone "https://osm.etsi.org/gerrit/osm/LCM" /home/ubuntu/LCM + $ juju config lcm lcm-hostpath=/home/ubuntu/LCM + + This configuration only applies if option `debug-mode` is set to true. + n2vc-hostpath: + type: string + description: | + Set this config to the local path of the N2VC module to persist the changes done during the + debug-mode session. + + Example: + $ git clone "https://osm.etsi.org/gerrit/osm/N2VC" /home/ubuntu/N2VC + $ juju config lcm n2vc-hostpath=/home/ubuntu/N2VC + + This configuration only applies if option `debug-mode` is set to true. + common-hostpath: + type: string + description: | + Set this config to the local path of the common module to persist the changes done during the + debug-mode session. + + Example: + $ git clone "https://osm.etsi.org/gerrit/osm/common" /home/ubuntu/common + $ juju config lcm common-hostpath=/home/ubuntu/common + + This configuration only applies if option `debug-mode` is set to true. diff --git a/installers/charm/osm-lcm/files/vscode-workspace.json b/installers/charm/osm-lcm/files/vscode-workspace.json new file mode 100644 index 00000000..f17b24dd --- /dev/null +++ b/installers/charm/osm-lcm/files/vscode-workspace.json @@ -0,0 +1,20 @@ +{ + "folders": [ + {"path": "/usr/lib/python3/dist-packages/osm_lcm"}, + {"path": "/usr/lib/python3/dist-packages/osm_common"}, + {"path": "/usr/lib/python3/dist-packages/n2vc"} + ], + "settings": {}, + "launch": { + "version": "0.2.0", + "configurations": [ + { + "name": "LCM", + "type": "python", + "request": "launch", + "module": "osm_lcm.lcm", + "justMyCode": false, + } + ] + } +} \ No newline at end of file diff --git a/installers/charm/osm-lcm/lib/charms/kafka_k8s/v0/kafka.py b/installers/charm/osm-lcm/lib/charms/kafka_k8s/v0/kafka.py new file mode 100644 index 00000000..aeb5edcb --- /dev/null +++ b/installers/charm/osm-lcm/lib/charms/kafka_k8s/v0/kafka.py @@ -0,0 +1,200 @@ +# Copyright 2022 Canonical Ltd. +# See LICENSE file for licensing details. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or +# implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Kafka library. + +This [library](https://juju.is/docs/sdk/libraries) implements both sides of the +`kafka` [interface](https://juju.is/docs/sdk/relations). + +The *provider* side of this interface is implemented by the +[kafka-k8s Charmed Operator](https://charmhub.io/kafka-k8s). + +Any Charmed Operator that *requires* Kafka for providing its +service should implement the *requirer* side of this interface. + +In a nutshell using this library to implement a Charmed Operator *requiring* +Kafka would look like + +``` +$ charmcraft fetch-lib charms.kafka_k8s.v0.kafka +``` + +`metadata.yaml`: + +``` +requires: + kafka: + interface: kafka + limit: 1 +``` + +`src/charm.py`: + +``` +from charms.kafka_k8s.v0.kafka import KafkaEvents, KafkaRequires +from ops.charm import CharmBase + + +class MyCharm(CharmBase): + + on = KafkaEvents() + + def __init__(self, *args): + super().__init__(*args) + self.kafka = KafkaRequires(self) + self.framework.observe( + self.on.kafka_available, + self._on_kafka_available, + ) + self.framework.observe( + self.on["kafka"].relation_broken, + self._on_kafka_broken, + ) + + def _on_kafka_available(self, event): + # Get Kafka host and port + host: str = self.kafka.host + port: int = self.kafka.port + # host => "kafka-k8s" + # port => 9092 + + def _on_kafka_broken(self, event): + # Stop service + # ... + self.unit.status = BlockedStatus("need kafka relation") +``` + +You can file bugs +[here](https://github.com/charmed-osm/kafka-k8s-operator/issues)! +""" + +from typing import Optional + +from ops.charm import CharmBase, CharmEvents +from ops.framework import EventBase, EventSource, Object + +# The unique Charmhub library identifier, never change it +from ops.model import Relation + +LIBID = "eacc8c85082347c9aae740e0220b8376" + +# Increment this major API version when introducing breaking changes +LIBAPI = 0 + +# Increment this PATCH version before using `charmcraft publish-lib` or reset +# to 0 if you are raising the major API version +LIBPATCH = 4 + + +KAFKA_HOST_APP_KEY = "host" +KAFKA_PORT_APP_KEY = "port" + + +class _KafkaAvailableEvent(EventBase): + """Event emitted when Kafka is available.""" + + +class KafkaEvents(CharmEvents): + """Kafka events. + + This class defines the events that Kafka can emit. + + Events: + kafka_available (_KafkaAvailableEvent) + """ + + kafka_available = EventSource(_KafkaAvailableEvent) + + +class KafkaRequires(Object): + """Requires-side of the Kafka relation.""" + + def __init__(self, charm: CharmBase, endpoint_name: str = "kafka") -> None: + super().__init__(charm, endpoint_name) + self.charm = charm + self._endpoint_name = endpoint_name + + # Observe relation events + event_observe_mapping = { + charm.on[self._endpoint_name].relation_changed: self._on_relation_changed, + } + for event, observer in event_observe_mapping.items(): + self.framework.observe(event, observer) + + def _on_relation_changed(self, event) -> None: + if event.relation.app and all( + key in event.relation.data[event.relation.app] + for key in (KAFKA_HOST_APP_KEY, KAFKA_PORT_APP_KEY) + ): + self.charm.on.kafka_available.emit() + + @property + def host(self) -> str: + """Get kafka hostname.""" + relation: Relation = self.model.get_relation(self._endpoint_name) + return ( + relation.data[relation.app].get(KAFKA_HOST_APP_KEY) + if relation and relation.app + else None + ) + + @property + def port(self) -> int: + """Get kafka port number.""" + relation: Relation = self.model.get_relation(self._endpoint_name) + return ( + int(relation.data[relation.app].get(KAFKA_PORT_APP_KEY)) + if relation and relation.app + else None + ) + + +class KafkaProvides(Object): + """Provides-side of the Kafka relation.""" + + def __init__(self, charm: CharmBase, endpoint_name: str = "kafka") -> None: + super().__init__(charm, endpoint_name) + self._endpoint_name = endpoint_name + + def set_host_info(self, host: str, port: int, relation: Optional[Relation] = None) -> None: + """Set Kafka host and port. + + This function writes in the application data of the relation, therefore, + only the unit leader can call it. + + Args: + host (str): Kafka hostname or IP address. + port (int): Kafka port. + relation (Optional[Relation]): Relation to update. + If not specified, all relations will be updated. + + Raises: + Exception: if a non-leader unit calls this function. + """ + if not self.model.unit.is_leader(): + raise Exception("only the leader set host information.") + + if relation: + self._update_relation_data(host, port, relation) + return + + for relation in self.model.relations[self._endpoint_name]: + self._update_relation_data(host, port, relation) + + def _update_relation_data(self, host: str, port: int, relation: Relation) -> None: + """Update data in relation if needed.""" + relation.data[self.model.app][KAFKA_HOST_APP_KEY] = host + relation.data[self.model.app][KAFKA_PORT_APP_KEY] = str(port) diff --git a/installers/charm/osm-lcm/lib/charms/osm_libs/v0/utils.py b/installers/charm/osm-lcm/lib/charms/osm_libs/v0/utils.py new file mode 100644 index 00000000..e686f824 --- /dev/null +++ b/installers/charm/osm-lcm/lib/charms/osm_libs/v0/utils.py @@ -0,0 +1,518 @@ +#!/usr/bin/env python3 +# Copyright 2022 Canonical Ltd. +# See LICENSE file for licensing details. +# http://www.apache.org/licenses/LICENSE-2.0 +"""OSM Utils Library. + +This library offers some utilities made for but not limited to Charmed OSM. + +# Getting started + +Execute the following command inside your Charmed Operator folder to fetch the library. + +```shell +charmcraft fetch-lib charms.osm_libs.v0.utils +``` + +# CharmError Exception + +An exception that takes to arguments, the message and the StatusBase class, which are useful +to set the status of the charm when the exception raises. + +Example: +```shell +from charms.osm_libs.v0.utils import CharmError + +class MyCharm(CharmBase): + def _on_config_changed(self, _): + try: + if not self.config.get("some-option"): + raise CharmError("need some-option", BlockedStatus) + + if not self.mysql_ready: + raise CharmError("waiting for mysql", WaitingStatus) + + # Do stuff... + + exception CharmError as e: + self.unit.status = e.status +``` + +# Pebble validations + +The `check_container_ready` function checks that a container is ready, +and therefore Pebble is ready. + +The `check_service_active` function checks that a service in a container is running. + +Both functions raise a CharmError if the validations fail. + +Example: +```shell +from charms.osm_libs.v0.utils import check_container_ready, check_service_active + +class MyCharm(CharmBase): + def _on_config_changed(self, _): + try: + container: Container = self.unit.get_container("my-container") + check_container_ready(container) + check_service_active(container, "my-service") + # Do stuff... + + exception CharmError as e: + self.unit.status = e.status +``` + +# Debug-mode + +The debug-mode allows OSM developers to easily debug OSM modules. + +Example: +```shell +from charms.osm_libs.v0.utils import DebugMode + +class MyCharm(CharmBase): + _stored = StoredState() + + def __init__(self, _): + # ... + container: Container = self.unit.get_container("my-container") + hostpaths = [ + HostPath( + config="module-hostpath", + container_path="/usr/lib/python3/dist-packages/module" + ), + ] + vscode_workspace_path = "files/vscode-workspace.json" + self.debug_mode = DebugMode( + self, + self._stored, + container, + hostpaths, + vscode_workspace_path, + ) + + def _on_update_status(self, _): + if self.debug_mode.started: + return + # ... + + def _get_debug_mode_information(self): + command = self.debug_mode.command + password = self.debug_mode.password + return command, password +``` + +# More + +- Get pod IP with `get_pod_ip()` +""" + +import logging +import secrets +import socket +from pathlib import Path +from typing import List + +from lightkube import Client +from lightkube.models.core_v1 import HostPathVolumeSource, Volume, VolumeMount +from lightkube.resources.apps_v1 import StatefulSet +from ops.charm import CharmBase +from ops.framework import Object, StoredState +from ops.model import ( + ActiveStatus, + BlockedStatus, + Container, + MaintenanceStatus, + StatusBase, + WaitingStatus, +) +from ops.pebble import ServiceStatus + +# The unique Charmhub library identifier, never change it +LIBID = "e915908eebee4cdd972d484728adf984" + +# Increment this major API version when introducing breaking changes +LIBAPI = 0 + +# Increment this PATCH version before using `charmcraft publish-lib` or reset +# to 0 if you are raising the major API version +LIBPATCH = 2 + +logger = logging.getLogger(__name__) + + +class CharmError(Exception): + """Charm Error Exception.""" + + def __init__(self, message: str, status_class: StatusBase = BlockedStatus) -> None: + self.message = message + self.status_class = status_class + self.status = status_class(message) + + +def check_container_ready(container: Container) -> None: + """Check Pebble has started in the container. + + Args: + container (Container): Container to be checked. + + Raises: + CharmError: if container is not ready. + """ + if not container.can_connect(): + raise CharmError("waiting for pebble to start", MaintenanceStatus) + + +def check_service_active(container: Container, service_name: str) -> None: + """Check if the service is running. + + Args: + container (Container): Container to be checked. + service_name (str): Name of the service to check. + + Raises: + CharmError: if the service is not running. + """ + if service_name not in container.get_plan().services: + raise CharmError(f"{service_name} service not configured yet", WaitingStatus) + + if container.get_service(service_name).current != ServiceStatus.ACTIVE: + raise CharmError(f"{service_name} service is not running") + + +def get_pod_ip() -> str: + """Get Kubernetes Pod IP. + + Returns: + str: The IP of the Pod. + """ + return socket.gethostbyname(socket.gethostname()) + + +_DEBUG_SCRIPT = r"""#!/bin/bash +# Install SSH + +function download_code(){{ + wget https://go.microsoft.com/fwlink/?LinkID=760868 -O code.deb +}} + +function setup_envs(){{ + grep "source /debug.envs" /root/.bashrc || echo "source /debug.envs" | tee -a /root/.bashrc +}} +function setup_ssh(){{ + apt install ssh -y + cat /etc/ssh/sshd_config | + grep -E '^PermitRootLogin yes$$' || ( + echo PermitRootLogin yes | + tee -a /etc/ssh/sshd_config + ) + service ssh stop + sleep 3 + service ssh start + usermod --password $(echo {} | openssl passwd -1 -stdin) root +}} + +function setup_code(){{ + apt install libasound2 -y + (dpkg -i code.deb || apt-get install -f -y || apt-get install -f -y) && echo Code installed successfully + code --install-extension ms-python.python --user-data-dir /root + mkdir -p /root/.vscode-server + cp -R /root/.vscode/extensions /root/.vscode-server/extensions +}} + +export DEBIAN_FRONTEND=noninteractive +apt update && apt install wget -y +download_code & +setup_ssh & +setup_envs +wait +setup_code & +wait +""" + + +class HostPath: + """Represents a hostpath.""" + + def __init__(self, config: str, container_path: str) -> None: + mount_path_items = config.split("-") + mount_path_items.reverse() + self.mount_path = "/" + "/".join(mount_path_items) + self.config = config + self.container_path = container_path + self.module_name = container_path.split("/")[-1] + + +class DebugMode(Object): + """Class to handle the debug-mode.""" + + def __init__( + self, + charm: CharmBase, + stored: StoredState, + container: Container, + hostpaths: List[HostPath] = [], + vscode_workspace_path: str = "files/vscode-workspace.json", + ) -> None: + super().__init__(charm, "debug-mode") + + self.charm = charm + self._stored = stored + self.hostpaths = hostpaths + self.vscode_workspace = Path(vscode_workspace_path).read_text() + self.container = container + + self._stored.set_default( + debug_mode_started=False, + debug_mode_vscode_command=None, + debug_mode_password=None, + ) + + self.framework.observe(self.charm.on.config_changed, self._on_config_changed) + self.framework.observe(self.charm.on[container.name].pebble_ready, self._on_config_changed) + self.framework.observe(self.charm.on.update_status, self._on_update_status) + + def _on_config_changed(self, _) -> None: + """Handler for the config-changed event.""" + if not self.charm.unit.is_leader(): + return + + debug_mode_enabled = self.charm.config.get("debug-mode", False) + action = self.enable if debug_mode_enabled else self.disable + action() + + def _on_update_status(self, _) -> None: + """Handler for the update-status event.""" + if not self.charm.unit.is_leader() or not self.started: + return + + self.charm.unit.status = ActiveStatus("debug-mode: ready") + + @property + def started(self) -> bool: + """Indicates whether the debug-mode has started or not.""" + return self._stored.debug_mode_started + + @property + def command(self) -> str: + """Command to launch vscode.""" + return self._stored.debug_mode_vscode_command + + @property + def password(self) -> str: + """SSH password.""" + return self._stored.debug_mode_password + + def enable(self, service_name: str = None) -> None: + """Enable debug-mode. + + This function mounts hostpaths of the OSM modules (if set), and + configures the container so it can be easily debugged. The setup + includes the configuration of SSH, environment variables, and + VSCode workspace and plugins. + + Args: + service_name (str, optional): Pebble service name which has the desired environment + variables. Mandatory if there is more than one Pebble service configured. + """ + hostpaths_to_reconfigure = self._hostpaths_to_reconfigure() + if self.started and not hostpaths_to_reconfigure: + self.charm.unit.status = ActiveStatus("debug-mode: ready") + return + + logger.debug("enabling debug-mode") + + # Mount hostpaths if set. + # If hostpaths are mounted, the statefulset will be restarted, + # and for that reason we return immediately. On restart, the hostpaths + # won't be mounted and then we can continue and setup the debug-mode. + if hostpaths_to_reconfigure: + self.charm.unit.status = MaintenanceStatus("debug-mode: configuring hostpaths") + self._configure_hostpaths(hostpaths_to_reconfigure) + return + + self.charm.unit.status = MaintenanceStatus("debug-mode: starting") + password = secrets.token_hex(8) + self._setup_debug_mode( + password, + service_name, + mounted_hostpaths=[hp for hp in self.hostpaths if self.charm.config.get(hp.config)], + ) + + self._stored.debug_mode_vscode_command = self._get_vscode_command(get_pod_ip()) + self._stored.debug_mode_password = password + self._stored.debug_mode_started = True + logger.info("debug-mode is ready") + self.charm.unit.status = ActiveStatus("debug-mode: ready") + + def disable(self) -> None: + """Disable debug-mode.""" + logger.debug("disabling debug-mode") + current_status = self.charm.unit.status + hostpaths_unmounted = self._unmount_hostpaths() + + if not self._stored.debug_mode_started: + return + self._stored.debug_mode_started = False + self._stored.debug_mode_vscode_command = None + self._stored.debug_mode_password = None + + if not hostpaths_unmounted: + self.charm.unit.status = current_status + self._restart() + + def _hostpaths_to_reconfigure(self) -> List[HostPath]: + hostpaths_to_reconfigure: List[HostPath] = [] + client = Client() + statefulset = client.get(StatefulSet, self.charm.app.name, namespace=self.charm.model.name) + volumes = statefulset.spec.template.spec.volumes + + for hostpath in self.hostpaths: + hostpath_is_set = True if self.charm.config.get(hostpath.config) else False + hostpath_already_configured = next( + (True for volume in volumes if volume.name == hostpath.config), False + ) + if hostpath_is_set != hostpath_already_configured: + hostpaths_to_reconfigure.append(hostpath) + + return hostpaths_to_reconfigure + + def _setup_debug_mode( + self, + password: str, + service_name: str = None, + mounted_hostpaths: List[HostPath] = [], + ) -> None: + services = self.container.get_plan().services + if not service_name and len(services) != 1: + raise Exception("Cannot start debug-mode: please set the service_name") + + service = None + if not service_name: + service_name, service = services.popitem() + if not service: + service = services.get(service_name) + + logger.debug(f"getting environment variables from service {service_name}") + environment = service.environment + environment_file_content = "\n".join( + [f'export {key}="{value}"' for key, value in environment.items()] + ) + logger.debug(f"pushing environment file to {self.container.name} container") + self.container.push("/debug.envs", environment_file_content) + + # Push VSCode workspace + logger.debug(f"pushing vscode workspace to {self.container.name} container") + self.container.push("/debug.code-workspace", self.vscode_workspace) + + # Execute debugging script + logger.debug(f"pushing debug-mode setup script to {self.container.name} container") + self.container.push("/debug.sh", _DEBUG_SCRIPT.format(password), permissions=0o777) + logger.debug(f"executing debug-mode setup script in {self.container.name} container") + self.container.exec(["/debug.sh"]).wait_output() + logger.debug(f"stopping service {service_name} in {self.container.name} container") + self.container.stop(service_name) + + # Add symlinks to mounted hostpaths + for hostpath in mounted_hostpaths: + logger.debug(f"adding symlink for {hostpath.config}") + self.container.exec(["rm", "-rf", hostpath.container_path]).wait_output() + self.container.exec( + [ + "ln", + "-s", + f"{hostpath.mount_path}/{hostpath.module_name}", + hostpath.container_path, + ] + ) + + def _configure_hostpaths(self, hostpaths: List[HostPath]): + client = Client() + statefulset = client.get(StatefulSet, self.charm.app.name, namespace=self.charm.model.name) + + for hostpath in hostpaths: + if self.charm.config.get(hostpath.config): + self._add_hostpath_to_statefulset(hostpath, statefulset) + else: + self._delete_hostpath_from_statefulset(hostpath, statefulset) + + client.replace(statefulset) + + def _unmount_hostpaths(self) -> bool: + client = Client() + hostpath_unmounted = False + statefulset = client.get(StatefulSet, self.charm.app.name, namespace=self.charm.model.name) + + for hostpath in self.hostpaths: + if self._delete_hostpath_from_statefulset(hostpath, statefulset): + hostpath_unmounted = True + + if hostpath_unmounted: + client.replace(statefulset) + + return hostpath_unmounted + + def _add_hostpath_to_statefulset(self, hostpath: HostPath, statefulset: StatefulSet): + # Add volume + logger.debug(f"adding volume {hostpath.config} to {self.charm.app.name} statefulset") + volume = Volume( + hostpath.config, + hostPath=HostPathVolumeSource( + path=self.charm.config[hostpath.config], + type="Directory", + ), + ) + statefulset.spec.template.spec.volumes.append(volume) + + # Add volumeMount + for statefulset_container in statefulset.spec.template.spec.containers: + if statefulset_container.name != self.container.name: + continue + + logger.debug( + f"adding volumeMount {hostpath.config} to {self.container.name} container" + ) + statefulset_container.volumeMounts.append( + VolumeMount(mountPath=hostpath.mount_path, name=hostpath.config) + ) + + def _delete_hostpath_from_statefulset(self, hostpath: HostPath, statefulset: StatefulSet): + hostpath_unmounted = False + for volume in statefulset.spec.template.spec.volumes: + + if hostpath.config != volume.name: + continue + + # Remove volumeMount + for statefulset_container in statefulset.spec.template.spec.containers: + if statefulset_container.name != self.container.name: + continue + for volume_mount in statefulset_container.volumeMounts: + if volume_mount.name != hostpath.config: + continue + + logger.debug( + f"removing volumeMount {hostpath.config} from {self.container.name} container" + ) + statefulset_container.volumeMounts.remove(volume_mount) + + # Remove volume + logger.debug( + f"removing volume {hostpath.config} from {self.charm.app.name} statefulset" + ) + statefulset.spec.template.spec.volumes.remove(volume) + + hostpath_unmounted = True + return hostpath_unmounted + + def _get_vscode_command( + self, + pod_ip: str, + user: str = "root", + workspace_path: str = "/debug.code-workspace", + ) -> str: + return f"code --remote ssh-remote+{user}@{pod_ip} {workspace_path}" + + def _restart(self): + self.container.exec(["kill", "-HUP", "1"]) diff --git a/installers/charm/osm-lcm/lib/charms/osm_ro/v0/ro.py b/installers/charm/osm-lcm/lib/charms/osm_ro/v0/ro.py new file mode 100644 index 00000000..79bee5e7 --- /dev/null +++ b/installers/charm/osm-lcm/lib/charms/osm_ro/v0/ro.py @@ -0,0 +1,178 @@ +#!/usr/bin/env python3 +# Copyright 2022 Canonical Ltd. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. +# +# For those usages not covered by the Apache License, Version 2.0 please +# contact: legal@canonical.com +# +# To get in touch with the maintainers, please contact: +# osm-charmers@lists.launchpad.net +# +# +# Learn more at: https://juju.is/docs/sdk + +"""Ro library. + +This [library](https://juju.is/docs/sdk/libraries) implements both sides of the +`ro` [interface](https://juju.is/docs/sdk/relations). + +The *provider* side of this interface is implemented by the +[osm-ro Charmed Operator](https://charmhub.io/osm-ro). + +Any Charmed Operator that *requires* RO for providing its +service should implement the *requirer* side of this interface. + +In a nutshell using this library to implement a Charmed Operator *requiring* +RO would look like + +``` +$ charmcraft fetch-lib charms.osm_ro.v0.ro +``` + +`metadata.yaml`: + +``` +requires: + ro: + interface: ro + limit: 1 +``` + +`src/charm.py`: + +``` +from charms.osm_ro.v0.ro import RoRequires +from ops.charm import CharmBase + + +class MyCharm(CharmBase): + + def __init__(self, *args): + super().__init__(*args) + self.ro = RoRequires(self) + self.framework.observe( + self.on["ro"].relation_changed, + self._on_ro_relation_changed, + ) + self.framework.observe( + self.on["ro"].relation_broken, + self._on_ro_relation_broken, + ) + self.framework.observe( + self.on["ro"].relation_broken, + self._on_ro_broken, + ) + + def _on_ro_relation_broken(self, event): + # Get RO host and port + host: str = self.ro.host + port: int = self.ro.port + # host => "osm-ro" + # port => 9999 + + def _on_ro_broken(self, event): + # Stop service + # ... + self.unit.status = BlockedStatus("need ro relation") +``` + +You can file bugs +[here](https://osm.etsi.org/bugzilla/enter_bug.cgi), selecting the `devops` module! +""" +from typing import Optional + +from ops.charm import CharmBase, CharmEvents +from ops.framework import EventBase, EventSource, Object +from ops.model import Relation + + +# The unique Charmhub library identifier, never change it +LIBID = "a34c3331a43f4f6db2b1499ff4d1390d" + +# Increment this major API version when introducing breaking changes +LIBAPI = 0 + +# Increment this PATCH version before using `charmcraft publish-lib` or reset +# to 0 if you are raising the major API version +LIBPATCH = 1 + +RO_HOST_APP_KEY = "host" +RO_PORT_APP_KEY = "port" + + +class RoRequires(Object): # pragma: no cover + """Requires-side of the Ro relation.""" + + def __init__(self, charm: CharmBase, endpoint_name: str = "ro") -> None: + super().__init__(charm, endpoint_name) + self.charm = charm + self._endpoint_name = endpoint_name + + @property + def host(self) -> str: + """Get ro hostname.""" + relation: Relation = self.model.get_relation(self._endpoint_name) + return ( + relation.data[relation.app].get(RO_HOST_APP_KEY) + if relation and relation.app + else None + ) + + @property + def port(self) -> int: + """Get ro port number.""" + relation: Relation = self.model.get_relation(self._endpoint_name) + return ( + int(relation.data[relation.app].get(RO_PORT_APP_KEY)) + if relation and relation.app + else None + ) + + +class RoProvides(Object): + """Provides-side of the Ro relation.""" + + def __init__(self, charm: CharmBase, endpoint_name: str = "ro") -> None: + super().__init__(charm, endpoint_name) + self._endpoint_name = endpoint_name + + def set_host_info(self, host: str, port: int, relation: Optional[Relation] = None) -> None: + """Set Ro host and port. + + This function writes in the application data of the relation, therefore, + only the unit leader can call it. + + Args: + host (str): Ro hostname or IP address. + port (int): Ro port. + relation (Optional[Relation]): Relation to update. + If not specified, all relations will be updated. + + Raises: + Exception: if a non-leader unit calls this function. + """ + if not self.model.unit.is_leader(): + raise Exception("only the leader set host information.") + + if relation: + self._update_relation_data(host, port, relation) + return + + for relation in self.model.relations[self._endpoint_name]: + self._update_relation_data(host, port, relation) + + def _update_relation_data(self, host: str, port: int, relation: Relation) -> None: + """Update data in relation if needed.""" + relation.data[self.model.app][RO_HOST_APP_KEY] = host + relation.data[self.model.app][RO_PORT_APP_KEY] = str(port) diff --git a/installers/charm/osm-lcm/lib/charms/osm_vca_integrator/v0/vca.py b/installers/charm/osm-lcm/lib/charms/osm_vca_integrator/v0/vca.py new file mode 100644 index 00000000..21dac69c --- /dev/null +++ b/installers/charm/osm-lcm/lib/charms/osm_vca_integrator/v0/vca.py @@ -0,0 +1,221 @@ +# Copyright 2022 Canonical Ltd. +# See LICENSE file for licensing details. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or +# implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""VCA Library. + +VCA stands for VNF Configuration and Abstraction, and is one of the core components +of OSM. The Juju Controller is in charged of this role. + +This [library](https://juju.is/docs/sdk/libraries) implements both sides of the +`vca` [interface](https://juju.is/docs/sdk/relations). + +The *provider* side of this interface is implemented by the +[osm-vca-integrator Charmed Operator](https://charmhub.io/osm-vca-integrator). + +helps to integrate with the +vca-integrator charm, which provides data needed to the OSM components that need +to talk to the VCA, and + +Any Charmed OSM component that *requires* to talk to the VCA should implement +the *requirer* side of this interface. + +In a nutshell using this library to implement a Charmed Operator *requiring* VCA data +would look like + +``` +$ charmcraft fetch-lib charms.osm_vca_integrator.v0.vca +``` + +`metadata.yaml`: + +``` +requires: + vca: + interface: osm-vca +``` + +`src/charm.py`: + +``` +from charms.osm_vca_integrator.v0.vca import VcaData, VcaIntegratorEvents, VcaRequires +from ops.charm import CharmBase + + +class MyCharm(CharmBase): + + on = VcaIntegratorEvents() + + def __init__(self, *args): + super().__init__(*args) + self.vca = VcaRequires(self) + self.framework.observe( + self.on.vca_data_changed, + self._on_vca_data_changed, + ) + + def _on_vca_data_changed(self, event): + # Get Vca data + data: VcaData = self.vca.data + # data.endpoints => "localhost:17070" +``` + +You can file bugs +[here](https://github.com/charmed-osm/osm-vca-integrator-operator/issues)! +""" + +import json +import logging +from typing import Any, Dict, Optional + +from ops.charm import CharmBase, CharmEvents, RelationChangedEvent +from ops.framework import EventBase, EventSource, Object + +# The unique Charmhub library identifier, never change it +from ops.model import Relation + +# The unique Charmhub library identifier, never change it +LIBID = "746b36c382984e5c8660b78192d84ef9" + +# Increment this major API version when introducing breaking changes +LIBAPI = 0 + +# Increment this PATCH version before using `charmcraft publish-lib` or reset +# to 0 if you are raising the major API version +LIBPATCH = 3 + + +logger = logging.getLogger(__name__) + + +class VcaDataChangedEvent(EventBase): + """Event emitted whenever there is a change in the vca data.""" + + def __init__(self, handle): + super().__init__(handle) + + +class VcaIntegratorEvents(CharmEvents): + """VCA Integrator events. + + This class defines the events that ZooKeeper can emit. + + Events: + vca_data_changed (_VcaDataChanged) + """ + + vca_data_changed = EventSource(VcaDataChangedEvent) + + +RELATION_MANDATORY_KEYS = ("endpoints", "user", "secret", "public-key", "cacert", "model-configs") + + +class VcaData: + """Vca data class.""" + + def __init__(self, data: Dict[str, Any]) -> None: + self.data: str = data + self.endpoints: str = data["endpoints"] + self.user: str = data["user"] + self.secret: str = data["secret"] + self.public_key: str = data["public-key"] + self.cacert: str = data["cacert"] + self.lxd_cloud: str = data.get("lxd-cloud") + self.lxd_credentials: str = data.get("lxd-credentials") + self.k8s_cloud: str = data.get("k8s-cloud") + self.k8s_credentials: str = data.get("k8s-credentials") + self.model_configs: Dict[str, Any] = data.get("model-configs", {}) + + +class VcaDataMissingError(Exception): + """Data missing exception.""" + + +class VcaRequires(Object): + """Requires part of the vca relation. + + Attributes: + endpoint_name: Endpoint name of the charm for the vca relation. + data: Vca data from the relation. + """ + + def __init__(self, charm: CharmBase, endpoint_name: str = "vca") -> None: + super().__init__(charm, endpoint_name) + self._charm = charm + self.endpoint_name = endpoint_name + self.framework.observe(charm.on[endpoint_name].relation_changed, self._on_relation_changed) + + @property + def data(self) -> Optional[VcaData]: + """Vca data from the relation.""" + relation: Relation = self.model.get_relation(self.endpoint_name) + if not relation or relation.app not in relation.data: + logger.debug("no application data in the event") + return + + relation_data: Dict = dict(relation.data[relation.app]) + relation_data["model-configs"] = json.loads(relation_data.get("model-configs", "{}")) + try: + self._validate_relation_data(relation_data) + return VcaData(relation_data) + except VcaDataMissingError as e: + logger.warning(e) + + def _on_relation_changed(self, event: RelationChangedEvent) -> None: + if event.app not in event.relation.data: + logger.debug("no application data in the event") + return + + relation_data = event.relation.data[event.app] + try: + self._validate_relation_data(relation_data) + self._charm.on.vca_data_changed.emit() + except VcaDataMissingError as e: + logger.warning(e) + + def _validate_relation_data(self, relation_data: Dict[str, str]) -> None: + if not all(required_key in relation_data for required_key in RELATION_MANDATORY_KEYS): + raise VcaDataMissingError("vca data not ready yet") + + clouds = ("lxd-cloud", "k8s-cloud") + if not any(cloud in relation_data for cloud in clouds): + raise VcaDataMissingError("no clouds defined yet") + + +class VcaProvides(Object): + """Provides part of the vca relation. + + Attributes: + endpoint_name: Endpoint name of the charm for the vca relation. + """ + + def __init__(self, charm: CharmBase, endpoint_name: str = "vca") -> None: + super().__init__(charm, endpoint_name) + self.endpoint_name = endpoint_name + + def update_vca_data(self, vca_data: VcaData) -> None: + """Update vca data in relation. + + Args: + vca_data: VcaData object. + """ + relation: Relation + for relation in self.model.relations[self.endpoint_name]: + if not relation or self.model.app not in relation.data: + logger.debug("relation app data not ready yet") + for key, value in vca_data.data.items(): + if key == "model-configs": + value = json.dumps(value) + relation.data[self.model.app][key] = value diff --git a/installers/charm/osm-lcm/metadata.yaml b/installers/charm/osm-lcm/metadata.yaml new file mode 100644 index 00000000..bd545417 --- /dev/null +++ b/installers/charm/osm-lcm/metadata.yaml @@ -0,0 +1,66 @@ +# Copyright 2022 Canonical Ltd. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. +# +# For those usages not covered by the Apache License, Version 2.0 please +# contact: legal@canonical.com +# +# To get in touch with the maintainers, please contact: +# osm-charmers@lists.launchpad.net +# +# +# This file populates the Overview on Charmhub. +# See https://juju.is/docs/some-url-to-be-determined/ for a checklist and guidance. + +name: osm-lcm + +# The following metadata are human-readable and will be published prominently on Charmhub. + +display-name: OSM LCM + +summary: OSM Lifecycle Management (LCM) + +description: | + A Kubernetes operator that deploys the OSM's Lifecycle Management (LCM). + + osm-lcm is the Lightweight Build Life Cycle Management for OSM. + It interact with RO module for resource orchestration and N2VC for VNF configuration. + + This charm doesn't make sense on its own. + See more: + - https://charmhub.io/osm + +containers: + lcm: + resource: lcm-image + +# This file populates the Resources tab on Charmhub. + +resources: + lcm-image: + type: oci-image + description: OCI image for lcm + upstream-source: opensourcemano/lcm + +requires: + kafka: + interface: kafka + limit: 1 + mongodb: + interface: mongodb + limit: 1 + ro: + interface: ro + limit: 1 + vca: + interface: osm-vca \ No newline at end of file diff --git a/installers/charm/osm-lcm/pyproject.toml b/installers/charm/osm-lcm/pyproject.toml new file mode 100644 index 00000000..d0d4a5bc --- /dev/null +++ b/installers/charm/osm-lcm/pyproject.toml @@ -0,0 +1,56 @@ +# Copyright 2022 Canonical Ltd. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. +# +# For those usages not covered by the Apache License, Version 2.0 please +# contact: legal@canonical.com +# +# To get in touch with the maintainers, please contact: +# osm-charmers@lists.launchpad.net + +# Testing tools configuration +[tool.coverage.run] +branch = true + +[tool.coverage.report] +show_missing = true + +[tool.pytest.ini_options] +minversion = "6.0" +log_cli_level = "INFO" + +# Formatting tools configuration +[tool.black] +line-length = 99 +target-version = ["py38"] + +[tool.isort] +profile = "black" + +# Linting tools configuration +[tool.flake8] +max-line-length = 99 +max-doc-length = 99 +max-complexity = 10 +exclude = [".git", "__pycache__", ".tox", "build", "dist", "*.egg_info", "venv"] +select = ["E", "W", "F", "C", "N", "R", "D", "H"] +# Ignore W503, E501 because using black creates errors with this +# Ignore D107 Missing docstring in __init__ +ignore = ["W503", "E501", "D107"] +# D100, D101, D102, D103: Ignore missing docstrings in tests +per-file-ignores = ["tests/*:D100,D101,D102,D103,D104"] +docstring-convention = "google" +# Check for properly formatted copyright header in each file +copyright-check = "True" +copyright-author = "Canonical Ltd." +copyright-regexp = "Copyright\\s\\d{4}([-,]\\d{4})*\\s+%(author)s" diff --git a/installers/charm/osm-lcm/requirements.txt b/installers/charm/osm-lcm/requirements.txt new file mode 100644 index 00000000..cb303a31 --- /dev/null +++ b/installers/charm/osm-lcm/requirements.txt @@ -0,0 +1,23 @@ +# Copyright 2022 Canonical Ltd. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. +# +# For those usages not covered by the Apache License, Version 2.0 please +# contact: legal@canonical.com +# +# To get in touch with the maintainers, please contact: +# osm-charmers@lists.launchpad.net +ops >= 1.2.0 +lightkube +lightkube-models +# git+https://github.com/charmed-osm/config-validator/ diff --git a/installers/charm/osm-lcm/src/charm.py b/installers/charm/osm-lcm/src/charm.py new file mode 100755 index 00000000..8c8c6e14 --- /dev/null +++ b/installers/charm/osm-lcm/src/charm.py @@ -0,0 +1,279 @@ +#!/usr/bin/env python3 +# Copyright 2022 Canonical Ltd. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. +# +# For those usages not covered by the Apache License, Version 2.0 please +# contact: legal@canonical.com +# +# To get in touch with the maintainers, please contact: +# osm-charmers@lists.launchpad.net +# +# +# Learn more at: https://juju.is/docs/sdk + +"""OSM LCM charm. + +See more: https://charmhub.io/osm +""" + +import logging +from typing import Any, Dict + +from charms.kafka_k8s.v0.kafka import KafkaRequires, _KafkaAvailableEvent +from charms.osm_libs.v0.utils import ( + CharmError, + DebugMode, + HostPath, + check_container_ready, + check_service_active, +) +from charms.osm_ro.v0.ro import RoRequires +from charms.osm_vca_integrator.v0.vca import VcaDataChangedEvent, VcaRequires +from ops.charm import ActionEvent, CharmBase, CharmEvents +from ops.framework import EventSource, StoredState +from ops.main import main +from ops.model import ActiveStatus, Container + +from legacy_interfaces import MongoClient + +HOSTPATHS = [ + HostPath( + config="lcm-hostpath", + container_path="/usr/lib/python3/dist-packages/osm_lcm", + ), + HostPath( + config="common-hostpath", + container_path="/usr/lib/python3/dist-packages/osm_common", + ), + HostPath( + config="n2vc-hostpath", + container_path="/usr/lib/python3/dist-packages/n2vc", + ), +] + +logger = logging.getLogger(__name__) + + +class LcmEvents(CharmEvents): + """LCM events.""" + + vca_data_changed = EventSource(VcaDataChangedEvent) + kafka_available = EventSource(_KafkaAvailableEvent) + + +class OsmLcmCharm(CharmBase): + """OSM LCM Kubernetes sidecar charm.""" + + container_name = "lcm" + service_name = "lcm" + on = LcmEvents() + _stored = StoredState() + + def __init__(self, *args): + super().__init__(*args) + self.vca = VcaRequires(self) + self.kafka = KafkaRequires(self) + self.mongodb_client = MongoClient(self, "mongodb") + self._observe_charm_events() + self.ro = RoRequires(self) + self.container: Container = self.unit.get_container(self.container_name) + self.debug_mode = DebugMode(self, self._stored, self.container, HOSTPATHS) + + # --------------------------------------------------------------------------- + # Handlers for Charm Events + # --------------------------------------------------------------------------- + + def _on_config_changed(self, _) -> None: + """Handler for the config-changed event.""" + try: + self._validate_config() + self._check_relations() + # Check if the container is ready. + # Eventually it will become ready after the first pebble-ready event. + check_container_ready(self.container) + self._configure_service(self.container) + + # Update charm status + self._on_update_status() + except CharmError as e: + logger.debug(e.message) + self.unit.status = e.status + + def _on_update_status(self, _=None) -> None: + """Handler for the update-status event.""" + try: + self._validate_config() + self._check_relations() + check_container_ready(self.container) + if self.debug_mode.started: + return + check_service_active(self.container, self.service_name) + self.unit.status = ActiveStatus() + except CharmError as e: + logger.debug(e.message) + self.unit.status = e.status + + def _on_required_relation_broken(self, _) -> None: + """Handler for required relation-broken events.""" + try: + check_container_ready(self.container) + check_service_active(self.container, self.service_name) + self.container.stop(self.container_name) + except CharmError: + pass + self._on_update_status() + + def _on_get_debug_mode_information_action(self, event: ActionEvent) -> None: + """Handler for the get-debug-mode-information action event.""" + if not self.debug_mode.started: + event.fail( + f"debug-mode has not started. Hint: juju config {self.app.name} debug-mode=true" + ) + return + + debug_info = {"command": self.debug_mode.command, "password": self.debug_mode.password} + event.set_results(debug_info) + + # --------------------------------------------------------------------------- + # Validation, configuration and more + # --------------------------------------------------------------------------- + + def _validate_config(self) -> None: + """Validate charm configuration. + + Raises: + CharmError: if charm configuration is invalid. + """ + logger.debug("validating charm config") + if self.config["log-level"].upper() not in [ + "TRACE", + "DEBUG", + "INFO", + "WARN", + "ERROR", + "FATAL", + ]: + raise CharmError("invalid value for log-level option") + + def _observe_charm_events(self) -> None: + event_handler_mapping = { + # Core lifecycle events + self.on.lcm_pebble_ready: self._on_config_changed, + self.on.config_changed: self._on_config_changed, + self.on.update_status: self._on_update_status, + # Relation events + self.on.kafka_available: self._on_config_changed, + self.on["kafka"].relation_broken: self._on_required_relation_broken, + self.on["mongodb"].relation_changed: self._on_config_changed, + self.on["mongodb"].relation_broken: self._on_required_relation_broken, + self.on["ro"].relation_changed: self._on_config_changed, + self.on["ro"].relation_broken: self._on_required_relation_broken, + self.on.vca_data_changed: self._on_config_changed, + self.on["vca"].relation_broken: self._on_config_changed, + # Action events + self.on.get_debug_mode_information_action: self._on_get_debug_mode_information_action, + } + for event, handler in event_handler_mapping.items(): + self.framework.observe(event, handler) + + def _check_relations(self) -> None: + """Validate charm relations. + + Raises: + CharmError: if charm configuration is invalid. + """ + logger.debug("check for missing relations") + missing_relations = [] + + if not self.kafka.host or not self.kafka.port: + missing_relations.append("kafka") + if self.mongodb_client.is_missing_data_in_unit(): + missing_relations.append("mongodb") + if not self.ro.host or not self.ro.port: + missing_relations.append("ro") + + if missing_relations: + relations_str = ", ".join(missing_relations) + one_relation_missing = len(missing_relations) == 1 + error_msg = f'need {relations_str} relation{"" if one_relation_missing else "s"}' + logger.warning(error_msg) + raise CharmError(error_msg) + + def _configure_service(self, container: Container) -> None: + """Add Pebble layer with the lcm service.""" + logger.debug(f"configuring {self.app.name} service") + container.add_layer("lcm", self._get_layer(), combine=True) + container.replan() + + def _get_layer(self) -> Dict[str, Any]: + """Get layer for Pebble.""" + environments = { + # General configuration + "OSMLCM_GLOBAL_LOGLEVEL": self.config["log-level"].upper(), + # Kafka configuration + "OSMLCM_MESSAGE_DRIVER": "kafka", + "OSMLCM_MESSAGE_HOST": self.kafka.host, + "OSMLCM_MESSAGE_PORT": self.kafka.port, + # RO configuration + "OSMLCM_RO_HOST": self.ro.host, + "OSMLCM_RO_PORT": self.ro.port, + "OSMLCM_RO_TENANT": "osm", + # Database configuration + "OSMLCM_DATABASE_DRIVER": "mongo", + "OSMLCM_DATABASE_URI": self.mongodb_client.connection_string, + "OSMLCM_DATABASE_COMMONKEY": self.config["database-commonkey"], + # Storage configuration + "OSMLCM_STORAGE_DRIVER": "mongo", + "OSMLCM_STORAGE_PATH": "/app/storage", + "OSMLCM_STORAGE_COLLECTION": "files", + "OSMLCM_STORAGE_URI": self.mongodb_client.connection_string, + "OSMLCM_VCA_HELM_CA_CERTS": self.config["helm-ca-certs"], + "OSMLCM_VCA_STABLEREPOURL": self.config["helm-stable-repo-url"], + } + # Vca configuration + if self.vca.data: + environments["OSMLCM_VCA_ENDPOINTS"] = self.vca.data.endpoints + environments["OSMLCM_VCA_USER"] = self.vca.data.user + environments["OSMLCM_VCA_PUBKEY"] = self.vca.data.public_key + environments["OSMLCM_VCA_SECRET"] = self.vca.data.secret + environments["OSMLCM_VCA_CACERT"] = self.vca.data.cacert + if self.vca.data.lxd_cloud: + environments["OSMLCM_VCA_CLOUD"] = self.vca.data.lxd_cloud + + if self.vca.data.k8s_cloud: + environments["OSMLCM_VCA_K8S_CLOUD"] = self.vca.data.k8s_cloud + for key, value in self.vca.data.model_configs.items(): + env_name = f'OSMLCM_VCA_MODEL_CONFIG_{key.upper().replace("-","_")}' + environments[env_name] = value + + layer_config = { + "summary": "lcm layer", + "description": "pebble config layer for nbi", + "services": { + self.service_name: { + "override": "replace", + "summary": "lcm service", + "command": "python3 -m osm_lcm.lcm", + "startup": "enabled", + "user": "appuser", + "group": "appuser", + "environment": environments, + } + }, + } + return layer_config + + +if __name__ == "__main__": # pragma: no cover + main(OsmLcmCharm) diff --git a/installers/charm/osm-lcm/src/legacy_interfaces.py b/installers/charm/osm-lcm/src/legacy_interfaces.py new file mode 100644 index 00000000..d56f31df --- /dev/null +++ b/installers/charm/osm-lcm/src/legacy_interfaces.py @@ -0,0 +1,107 @@ +#!/usr/bin/env python3 +# Copyright 2022 Canonical Ltd. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. +# +# For those usages not covered by the Apache License, Version 2.0 please +# contact: legal@canonical.com +# +# To get in touch with the maintainers, please contact: +# osm-charmers@lists.launchpad.net +# +# flake8: noqa + +import ops + + +class BaseRelationClient(ops.framework.Object): + """Requires side of a Kafka Endpoint""" + + def __init__( + self, charm: ops.charm.CharmBase, relation_name: str, mandatory_fields: list = [] + ): + super().__init__(charm, relation_name) + self.relation_name = relation_name + self.mandatory_fields = mandatory_fields + self._update_relation() + + def get_data_from_unit(self, key: str): + if not self.relation: + # This update relation doesn't seem to be needed, but I added it because apparently + # the data is empty in the unit tests. + # In reality, the constructor is called in every hook. + # In the unit tests when doing an update_relation_data, apparently it is not called. + self._update_relation() + if self.relation: + for unit in self.relation.units: + data = self.relation.data[unit].get(key) + if data: + return data + + def get_data_from_app(self, key: str): + if not self.relation or self.relation.app not in self.relation.data: + # This update relation doesn't seem to be needed, but I added it because apparently + # the data is empty in the unit tests. + # In reality, the constructor is called in every hook. + # In the unit tests when doing an update_relation_data, apparently it is not called. + self._update_relation() + if self.relation and self.relation.app in self.relation.data: + data = self.relation.data[self.relation.app].get(key) + if data: + return data + + def is_missing_data_in_unit(self): + return not all([self.get_data_from_unit(field) for field in self.mandatory_fields]) + + def is_missing_data_in_app(self): + return not all([self.get_data_from_app(field) for field in self.mandatory_fields]) + + def _update_relation(self): + self.relation = self.framework.model.get_relation(self.relation_name) + + +class MongoClient(BaseRelationClient): + """Requires side of a Mongo Endpoint""" + + mandatory_fields_mapping = { + "reactive": ["connection_string"], + "ops": ["replica_set_uri", "replica_set_name"], + } + + def __init__(self, charm: ops.charm.CharmBase, relation_name: str): + super().__init__(charm, relation_name, mandatory_fields=[]) + + @property + def connection_string(self): + if self.is_opts(): + replica_set_uri = self.get_data_from_unit("replica_set_uri") + replica_set_name = self.get_data_from_unit("replica_set_name") + return f"{replica_set_uri}?replicaSet={replica_set_name}" + else: + return self.get_data_from_unit("connection_string") + + def is_opts(self): + return not self.is_missing_data_in_unit_ops() + + def is_missing_data_in_unit(self): + return self.is_missing_data_in_unit_ops() and self.is_missing_data_in_unit_reactive() + + def is_missing_data_in_unit_ops(self): + return not all( + [self.get_data_from_unit(field) for field in self.mandatory_fields_mapping["ops"]] + ) + + def is_missing_data_in_unit_reactive(self): + return not all( + [self.get_data_from_unit(field) for field in self.mandatory_fields_mapping["reactive"]] + ) diff --git a/installers/charm/osm-lcm/tests/unit/test_charm.py b/installers/charm/osm-lcm/tests/unit/test_charm.py new file mode 100644 index 00000000..56c7ab8b --- /dev/null +++ b/installers/charm/osm-lcm/tests/unit/test_charm.py @@ -0,0 +1,85 @@ +#!/usr/bin/env python3 +# Copyright 2022 Canonical Ltd. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. +# +# For those usages not covered by the Apache License, Version 2.0 please +# contact: legal@canonical.com +# +# To get in touch with the maintainers, please contact: +# osm-charmers@lists.launchpad.net +# +# Learn more about testing at: https://juju.is/docs/sdk/testing + +import pytest +from ops.model import ActiveStatus, BlockedStatus +from ops.testing import Harness +from pytest_mock import MockerFixture + +from charm import CharmError, OsmLcmCharm, check_service_active + +container_name = "lcm" +service_name = "lcm" + + +@pytest.fixture +def harness(mocker: MockerFixture): + harness = Harness(OsmLcmCharm) + harness.begin() + yield harness + harness.cleanup() + + +def test_missing_relations(harness: Harness): + harness.charm.on.config_changed.emit() + assert type(harness.charm.unit.status) == BlockedStatus + assert all( + relation in harness.charm.unit.status.message for relation in ["mongodb", "kafka", "ro"] + ) + + +def test_ready(harness: Harness): + _add_relations(harness) + assert harness.charm.unit.status == ActiveStatus() + + +def test_container_stops_after_relation_broken(harness: Harness): + harness.charm.on[container_name].pebble_ready.emit(container_name) + container = harness.charm.unit.get_container(container_name) + relation_ids = _add_relations(harness) + check_service_active(container, service_name) + harness.remove_relation(relation_ids[0]) + with pytest.raises(CharmError): + check_service_active(container, service_name) + + +def _add_relations(harness: Harness): + relation_ids = [] + # Add mongo relation + relation_id = harness.add_relation("mongodb", "mongodb") + harness.add_relation_unit(relation_id, "mongodb/0") + harness.update_relation_data( + relation_id, "mongodb/0", {"connection_string": "mongodb://:1234"} + ) + relation_ids.append(relation_id) + # Add kafka relation + relation_id = harness.add_relation("kafka", "kafka") + harness.add_relation_unit(relation_id, "kafka/0") + harness.update_relation_data(relation_id, "kafka", {"host": "kafka", "port": 9092}) + relation_ids.append(relation_id) + # Add ro relation + relation_id = harness.add_relation("ro", "ro") + harness.add_relation_unit(relation_id, "ro/0") + harness.update_relation_data(relation_id, "ro", {"host": "ro", "port": 9090}) + relation_ids.append(relation_id) + return relation_ids diff --git a/installers/charm/osm-lcm/tox.ini b/installers/charm/osm-lcm/tox.ini new file mode 100644 index 00000000..275137c3 --- /dev/null +++ b/installers/charm/osm-lcm/tox.ini @@ -0,0 +1,92 @@ +# Copyright 2022 Canonical Ltd. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. +# +# For those usages not covered by the Apache License, Version 2.0 please +# contact: legal@canonical.com +# +# To get in touch with the maintainers, please contact: +# osm-charmers@lists.launchpad.net + +[tox] +skipsdist=True +skip_missing_interpreters = True +envlist = lint, unit + +[vars] +src_path = {toxinidir}/src/ +tst_path = {toxinidir}/tests/ +all_path = {[vars]src_path} {[vars]tst_path} + +[testenv] +setenv = + PYTHONPATH = {toxinidir}:{toxinidir}/lib:{[vars]src_path} + PYTHONBREAKPOINT=ipdb.set_trace + PY_COLORS=1 +passenv = + PYTHONPATH + CHARM_BUILD_DIR + MODEL_SETTINGS + +[testenv:fmt] +description = Apply coding style standards to code +deps = + black + isort +commands = + isort {[vars]all_path} + black {[vars]all_path} + +[testenv:lint] +description = Check code against coding style standards +deps = + black + flake8 + flake8-docstrings + flake8-copyright + flake8-builtins + pyproject-flake8 + pep8-naming + isort + codespell +commands = + codespell {toxinidir}/. --skip {toxinidir}/.git --skip {toxinidir}/.tox \ + --skip {toxinidir}/build --skip {toxinidir}/lib --skip {toxinidir}/venv \ + --skip {toxinidir}/.mypy_cache --skip {toxinidir}/icon.svg + # pflake8 wrapper supports config from pyproject.toml + pflake8 {[vars]all_path} + isort --check-only --diff {[vars]all_path} + black --check --diff {[vars]all_path} + +[testenv:unit] +description = Run unit tests +deps = + pytest + pytest-mock + coverage[toml] + -r{toxinidir}/requirements.txt +commands = + coverage run --source={[vars]src_path} \ + -m pytest --ignore={[vars]tst_path}integration -v --tb native -s {posargs} + coverage report + coverage xml + +[testenv:integration] +description = Run integration tests +deps = + pytest + juju + pytest-operator + -r{toxinidir}/requirements.txt +commands = + pytest -v --tb native --ignore={[vars]tst_path}unit --log-cli-level=INFO -s {posargs} -- 2.17.1