--- /dev/null
+#!/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
--- /dev/null
+#!/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
--- /dev/null
+<!-- 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 -->
+
+# 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="<root>=INFO;unit=DEBUG"
+# Deploy the charm
+juju deploy ./osm-mon_ubuntu-20.04-amd64.charm \
+ --resource mon-image=opensourcemano/mon:testing-daily
+```
--- /dev/null
+
+ 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.
--- /dev/null
+<!-- 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 -->
+
+<!--
+Avoid using this README file for information that is maintained or published elsewhere, e.g.:
+
+* metadata.yaml > published on Charmhub
+* documentation > published on (or linked to from) Charmhub
+* detailed contribution guide > documentation or CONTRIBUTING.md
+
+Use links instead.
+-->
+
+# OSM MON
+
+Charmhub package name: osm-mon
+More information: https://charmhub.io/osm-mon
+
+## 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-mon/CONTRIBUTING.md)
+
+* See the [Juju SDK documentation](https://juju.is/docs/sdk) for more information about developing and improving charms.
+
--- /dev/null
+# 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
--- /dev/null
+# 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: "20.04"
+ run-on:
+ - name: "ubuntu"
+ channel: "20.04"
+
+parts:
+ charm:
+ # build-packages:
+ # - git
+ prime:
+ - files/*
\ No newline at end of file
--- /dev/null
+# 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
+ openstack-default-granularity:
+ description: Openstack default granularity
+ type: int
+ default: 300
+ global-request-timeout:
+ description: Global request timeout
+ type: int
+ default: 10
+ collector-interval:
+ description: Collector interval
+ type: int
+ default: 30
+ evaluator-interval:
+ description: Evaluator interval
+ type: int
+ default: 30
+ grafana-url:
+ description: Grafana URL
+ type: string
+ default: http://grafana:3000
+ grafana-user:
+ description: Grafana user
+ type: string
+ default: admin
+ grafana-password:
+ description: Grafana password
+ type: string
+ default: admin
+ keystone-enabled:
+ description: MON will use Keystone backend
+ type: boolean
+ default: false
+ certificates:
+ type: string
+ description: |
+ comma-separated list of <name>:<content> certificates.
+ Where:
+ name: name of the file for the certificate
+ content: base64 content of the certificate
+ The path for the files is /certs.
+
+ # 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 <unit name> --wait`
+
+ The previous command returns the command you need to execute, and the SSH password that was set.
+
+ See also:
+ - https://charmhub.io/osm-mon/configure#mon-hostpath
+ - https://charmhub.io/osm-mon/configure#common-hostpath
+ - https://charmhub.io/osm-mon/configure#n2vc-hostpath
+ default: false
+ mon-hostpath:
+ type: string
+ description: |
+ Set this config to the local path of the MON module to persist the changes done during the
+ debug-mode session.
+
+ Example:
+ $ git clone "https://osm.etsi.org/gerrit/osm/MON" /home/ubuntu/MON
+ $ juju config mon mon-hostpath=/home/ubuntu/MON
+
+ 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 mon common-hostpath=/home/ubuntu/common
+
+ 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 mon n2vc-hostpath=/home/ubuntu/N2VC
+
+ This configuration only applies if option `debug-mode` is set to true.
--- /dev/null
+{
+ "folders": [
+ {"path": "/usr/lib/python3/dist-packages/osm_mon"},
+ {"path": "/usr/lib/python3/dist-packages/osm_common"},
+ {"path": "/usr/lib/python3/dist-packages/n2vc"},
+ ],
+ "settings": {},
+ "launch": {
+ "version": "0.2.0",
+ "configurations": [
+ {
+ "name": "MON",
+ "type": "python",
+ "request": "launch",
+ "module": "osm_mon.nbi",
+ "justMyCode": false,
+ }
+
+ {
+ "name": "MON Server",
+ "type": "python",
+ "request": "launch",
+ "module": "osm_mon.cmd.mon_server",
+ "justMyCode": false,
+ },
+ {
+ "name": "MON evaluator",
+ "type": "python",
+ "request": "launch",
+ "module": "osm_mon.cmd.mon_evaluator",
+ "justMyCode": false,
+ },
+ {
+ "name": "MON collector",
+ "type": "python",
+ "request": "launch",
+ "module": "osm_mon.cmd.mon_collector",
+ "justMyCode": false,
+ },
+ {
+ "name": "MON dashboarder",
+ "type": "python",
+ "request": "launch",
+ "module": "osm_mon.cmd.mon_dashboarder",
+ "justMyCode": false,
+ },
+ ],
+ }
+}
\ No newline at end of file
--- /dev/null
+# 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)
--- /dev/null
+# Copyright 2021 Canonical Ltd.
+# See LICENSE file for licensing details.
+# http://www.apache.org/licenses/LICENSE-2.0
+
+"""# KubernetesServicePatch Library.
+
+This library is designed to enable developers to more simply patch the Kubernetes Service created
+by Juju during the deployment of a sidecar charm. When sidecar charms are deployed, Juju creates a
+service named after the application in the namespace (named after the Juju model). This service by
+default contains a "placeholder" port, which is 65536/TCP.
+
+When modifying the default set of resources managed by Juju, one must consider the lifecycle of the
+charm. In this case, any modifications to the default service (created during deployment), will be
+overwritten during a charm upgrade.
+
+When initialised, this library binds a handler to the parent charm's `install` and `upgrade_charm`
+events which applies the patch to the cluster. This should ensure that the service ports are
+correct throughout the charm's life.
+
+The constructor simply takes a reference to the parent charm, and a list of
+[`lightkube`](https://github.com/gtsystem/lightkube) ServicePorts that each define a port for the
+service. For information regarding the `lightkube` `ServicePort` model, please visit the
+`lightkube` [docs](https://gtsystem.github.io/lightkube-models/1.23/models/core_v1/#serviceport).
+
+Optionally, a name of the service (in case service name needs to be patched as well), labels,
+selectors, and annotations can be provided as keyword arguments.
+
+## Getting Started
+
+To get started using the library, you just need to fetch the library using `charmcraft`. **Note
+that you also need to add `lightkube` and `lightkube-models` to your charm's `requirements.txt`.**
+
+```shell
+cd some-charm
+charmcraft fetch-lib charms.observability_libs.v0.kubernetes_service_patch
+echo <<-EOF >> requirements.txt
+lightkube
+lightkube-models
+EOF
+```
+
+Then, to initialise the library:
+
+For `ClusterIP` services:
+
+```python
+# ...
+from charms.observability_libs.v0.kubernetes_service_patch import KubernetesServicePatch
+from lightkube.models.core_v1 import ServicePort
+
+class SomeCharm(CharmBase):
+ def __init__(self, *args):
+ # ...
+ port = ServicePort(443, name=f"{self.app.name}")
+ self.service_patcher = KubernetesServicePatch(self, [port])
+ # ...
+```
+
+For `LoadBalancer`/`NodePort` services:
+
+```python
+# ...
+from charms.observability_libs.v0.kubernetes_service_patch import KubernetesServicePatch
+from lightkube.models.core_v1 import ServicePort
+
+class SomeCharm(CharmBase):
+ def __init__(self, *args):
+ # ...
+ port = ServicePort(443, name=f"{self.app.name}", targetPort=443, nodePort=30666)
+ self.service_patcher = KubernetesServicePatch(
+ self, [port], "LoadBalancer"
+ )
+ # ...
+```
+
+Port protocols can also be specified. Valid protocols are `"TCP"`, `"UDP"`, and `"SCTP"`
+
+```python
+# ...
+from charms.observability_libs.v0.kubernetes_service_patch import KubernetesServicePatch
+from lightkube.models.core_v1 import ServicePort
+
+class SomeCharm(CharmBase):
+ def __init__(self, *args):
+ # ...
+ tcp = ServicePort(443, name=f"{self.app.name}-tcp", protocol="TCP")
+ udp = ServicePort(443, name=f"{self.app.name}-udp", protocol="UDP")
+ sctp = ServicePort(443, name=f"{self.app.name}-sctp", protocol="SCTP")
+ self.service_patcher = KubernetesServicePatch(self, [tcp, udp, sctp])
+ # ...
+```
+
+Additionally, you may wish to use mocks in your charm's unit testing to ensure that the library
+does not try to make any API calls, or open any files during testing that are unlikely to be
+present, and could break your tests. The easiest way to do this is during your test `setUp`:
+
+```python
+# ...
+
+@patch("charm.KubernetesServicePatch", lambda x, y: None)
+def setUp(self, *unused):
+ self.harness = Harness(SomeCharm)
+ # ...
+```
+"""
+
+import logging
+from types import MethodType
+from typing import List, Literal
+
+from lightkube import ApiError, Client
+from lightkube.models.core_v1 import ServicePort, ServiceSpec
+from lightkube.models.meta_v1 import ObjectMeta
+from lightkube.resources.core_v1 import Service
+from lightkube.types import PatchType
+from ops.charm import CharmBase
+from ops.framework import Object
+
+logger = logging.getLogger(__name__)
+
+# The unique Charmhub library identifier, never change it
+LIBID = "0042f86d0a874435adef581806cddbbb"
+
+# Increment this major API version when introducing breaking changes
+LIBAPI = 1
+
+# Increment this PATCH version before using `charmcraft publish-lib` or reset
+# to 0 if you are raising the major API version
+LIBPATCH = 1
+
+ServiceType = Literal["ClusterIP", "LoadBalancer"]
+
+
+class KubernetesServicePatch(Object):
+ """A utility for patching the Kubernetes service set up by Juju."""
+
+ def __init__(
+ self,
+ charm: CharmBase,
+ ports: List[ServicePort],
+ service_name: str = None,
+ service_type: ServiceType = "ClusterIP",
+ additional_labels: dict = None,
+ additional_selectors: dict = None,
+ additional_annotations: dict = None,
+ ):
+ """Constructor for KubernetesServicePatch.
+
+ Args:
+ charm: the charm that is instantiating the library.
+ ports: a list of ServicePorts
+ service_name: allows setting custom name to the patched service. If none given,
+ application name will be used.
+ service_type: desired type of K8s service. Default value is in line with ServiceSpec's
+ default value.
+ additional_labels: Labels to be added to the kubernetes service (by default only
+ "app.kubernetes.io/name" is set to the service name)
+ additional_selectors: Selectors to be added to the kubernetes service (by default only
+ "app.kubernetes.io/name" is set to the service name)
+ additional_annotations: Annotations to be added to the kubernetes service.
+ """
+ super().__init__(charm, "kubernetes-service-patch")
+ self.charm = charm
+ self.service_name = service_name if service_name else self._app
+ self.service = self._service_object(
+ ports,
+ service_name,
+ service_type,
+ additional_labels,
+ additional_selectors,
+ additional_annotations,
+ )
+
+ # Make mypy type checking happy that self._patch is a method
+ assert isinstance(self._patch, MethodType)
+ # Ensure this patch is applied during the 'install' and 'upgrade-charm' events
+ self.framework.observe(charm.on.install, self._patch)
+ self.framework.observe(charm.on.upgrade_charm, self._patch)
+
+ def _service_object(
+ self,
+ ports: List[ServicePort],
+ service_name: str = None,
+ service_type: ServiceType = "ClusterIP",
+ additional_labels: dict = None,
+ additional_selectors: dict = None,
+ additional_annotations: dict = None,
+ ) -> Service:
+ """Creates a valid Service representation.
+
+ Args:
+ ports: a list of ServicePorts
+ service_name: allows setting custom name to the patched service. If none given,
+ application name will be used.
+ service_type: desired type of K8s service. Default value is in line with ServiceSpec's
+ default value.
+ additional_labels: Labels to be added to the kubernetes service (by default only
+ "app.kubernetes.io/name" is set to the service name)
+ additional_selectors: Selectors to be added to the kubernetes service (by default only
+ "app.kubernetes.io/name" is set to the service name)
+ additional_annotations: Annotations to be added to the kubernetes service.
+
+ Returns:
+ Service: A valid representation of a Kubernetes Service with the correct ports.
+ """
+ if not service_name:
+ service_name = self._app
+ labels = {"app.kubernetes.io/name": self._app}
+ if additional_labels:
+ labels.update(additional_labels)
+ selector = {"app.kubernetes.io/name": self._app}
+ if additional_selectors:
+ selector.update(additional_selectors)
+ return Service(
+ apiVersion="v1",
+ kind="Service",
+ metadata=ObjectMeta(
+ namespace=self._namespace,
+ name=service_name,
+ labels=labels,
+ annotations=additional_annotations, # type: ignore[arg-type]
+ ),
+ spec=ServiceSpec(
+ selector=selector,
+ ports=ports,
+ type=service_type,
+ ),
+ )
+
+ def _patch(self, _) -> None:
+ """Patch the Kubernetes service created by Juju to map the correct port.
+
+ Raises:
+ PatchFailed: if patching fails due to lack of permissions, or otherwise.
+ """
+ if not self.charm.unit.is_leader():
+ return
+
+ client = Client()
+ try:
+ if self.service_name != self._app:
+ self._delete_and_create_service(client)
+ client.patch(Service, self.service_name, self.service, patch_type=PatchType.MERGE)
+ except ApiError as e:
+ if e.status.code == 403:
+ logger.error("Kubernetes service patch failed: `juju trust` this application.")
+ else:
+ logger.error("Kubernetes service patch failed: %s", str(e))
+ else:
+ logger.info("Kubernetes service '%s' patched successfully", self._app)
+
+ def _delete_and_create_service(self, client: Client):
+ service = client.get(Service, self._app, namespace=self._namespace)
+ service.metadata.name = self.service_name # type: ignore[attr-defined]
+ service.metadata.resourceVersion = service.metadata.uid = None # type: ignore[attr-defined] # noqa: E501
+ client.delete(Service, self._app, namespace=self._namespace)
+ client.create(service)
+
+ def is_patched(self) -> bool:
+ """Reports if the service patch has been applied.
+
+ Returns:
+ bool: A boolean indicating if the service patch has been applied.
+ """
+ client = Client()
+ # Get the relevant service from the cluster
+ service = client.get(Service, name=self.service_name, namespace=self._namespace)
+ # Construct a list of expected ports, should the patch be applied
+ expected_ports = [(p.port, p.targetPort) for p in self.service.spec.ports]
+ # Construct a list in the same manner, using the fetched service
+ fetched_ports = [(p.port, p.targetPort) for p in service.spec.ports] # type: ignore[attr-defined] # noqa: E501
+ return expected_ports == fetched_ports
+
+ @property
+ def _app(self) -> str:
+ """Name of the current Juju application.
+
+ Returns:
+ str: A string containing the name of the current Juju application.
+ """
+ return self.charm.app.name
+
+ @property
+ def _namespace(self) -> str:
+ """The Kubernetes namespace we're running in.
+
+ Returns:
+ str: A string containing the name of the current Kubernetes namespace.
+ """
+ with open("/var/run/secrets/kubernetes.io/serviceaccount/namespace", "r") as f:
+ return f.read().strip()
--- /dev/null
+#!/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"])
--- /dev/null
+# 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
--- /dev/null
+# 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-mon
+
+# The following metadata are human-readable and will be published prominently on Charmhub.
+
+display-name: OSM MON
+
+summary: OSM Monitoring Service (MON)
+
+description: |
+ A Kubernetes operator that deploys the Monitoring Service of OSM.
+
+ TODO: two sentences on MON
+
+ Small paragraph
+
+ This charm doesn't make sense on its own.
+ See more:
+ - https://charmhub.io/osm
+
+containers:
+ mon:
+ resource: mon-image
+
+# This file populates the Resources tab on Charmhub.
+
+resources:
+ mon-image:
+ type: oci-image
+ description: OCI image for mon
+ upstream-source: opensourcemano/mon
+
+requires:
+ kafka:
+ interface: kafka
+ limit: 1
+ mongodb:
+ interface: mongodb
+ limit: 1
+ keystone:
+ interface: keystone
+ limit: 1
+ prometheus:
+ interface: prometheus
+ limit: 1
+ vca:
+ interface: osm-vca
--- /dev/null
+# 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"
--- /dev/null
+# 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/
--- /dev/null
+#!/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 NBI 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.observability_libs.v1.kubernetes_service_patch import KubernetesServicePatch
+from charms.osm_libs.v0.utils import (
+ CharmError,
+ DebugMode,
+ HostPath,
+ check_container_ready,
+ check_service_active,
+)
+from charms.osm_vca_integrator.v0.vca import VcaDataChangedEvent, VcaRequires
+from lightkube.models.core_v1 import ServicePort
+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 KeystoneClient, MongoClient, PrometheusClient
+
+HOSTPATHS = [
+ HostPath(
+ config="mon-hostpath",
+ container_path="/usr/lib/python3/dist-packages/osm_mon",
+ ),
+ 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",
+ ),
+]
+SERVICE_PORT = 8000
+
+logger = logging.getLogger(__name__)
+
+
+class MonEvents(CharmEvents):
+ """MON events."""
+
+ vca_data_changed = EventSource(VcaDataChangedEvent)
+ kafka_available = EventSource(_KafkaAvailableEvent)
+
+
+class OsmMonCharm(CharmBase):
+ """OSM MON Kubernetes sidecar charm."""
+
+ on = MonEvents()
+ _stored = StoredState()
+ container_name = "mon"
+ service_name = "mon"
+
+ def __init__(self, *args):
+ super().__init__(*args)
+ self.kafka = KafkaRequires(self)
+ self.mongodb_client = MongoClient(self, "mongodb")
+ self.prometheus_client = PrometheusClient(self, "prometheus")
+ self.keystone_client = KeystoneClient(self, "keystone")
+ self.vca = VcaRequires(self)
+ self._observe_charm_events()
+ self.container: Container = self.unit.get_container(self.container_name)
+ self.debug_mode = DebugMode(self, self._stored, self.container, HOSTPATHS)
+ self._patch_k8s_service()
+
+ @property
+ def external_hostname(self) -> str:
+ """External hostname property.
+
+ Returns:
+ str: the external hostname from config.
+ If not set, return the ClusterIP service name.
+ """
+ return self.config.get("external-hostname") or self.app.name
+
+ # ---------------------------------------------------------------------------
+ # 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 the kafka-broken event."""
+ 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("debug-mode has not started. Hint: juju config mon debug-mode=true")
+ return
+
+ debug_info = {"command": self.debug_mode.command, "password": self.debug_mode.password}
+ event.set_results(debug_info)
+
+ # ---------------------------------------------------------------------------
+ # Validation and configuration and more
+ # ---------------------------------------------------------------------------
+
+ def _observe_charm_events(self) -> None:
+ event_handler_mapping = {
+ # Core lifecycle events
+ self.on.mon_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.vca_data_changed: self._on_config_changed,
+ self.on.kafka_available: self._on_config_changed,
+ self.on["kafka"].relation_broken: self._on_required_relation_broken,
+ # Action events
+ self.on.get_debug_mode_information_action: self._on_get_debug_mode_information_action,
+ }
+ for relation in [self.on[rel_name] for rel_name in ["mongodb", "prometheus", "keystone"]]:
+ event_handler_mapping[relation.relation_changed] = self._on_config_changed
+ event_handler_mapping[relation.relation_broken] = self._on_required_relation_broken
+
+ for event, handler in event_handler_mapping.items():
+ self.framework.observe(event, handler)
+
+ def _validate_config(self) -> None:
+ """Validate charm configuration.
+
+ Raises:
+ CharmError: if charm configuration is invalid.
+ """
+ logger.debug("validating charm config")
+
+ 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 self.prometheus_client.is_missing_data_in_app():
+ missing_relations.append("prometheus")
+ if self.keystone_client.is_missing_data_in_app():
+ missing_relations.append("keystone")
+
+ 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 mon service."""
+ logger.debug(f"configuring {self.app.name} service")
+ container.add_layer("mon", self._get_layer(), combine=True)
+ container.replan()
+
+ def _get_layer(self) -> Dict[str, Any]:
+ """Get layer for Pebble."""
+ environment = {
+ # General configuration
+ "OSMMON_GLOBAL_LOGLEVEL": self.config["log-level"],
+ "OSMMON_OPENSTACK_DEFAULT_GRANULARITY": self.config["openstack-default-granularity"],
+ "OSMMON_GLOBAL_REQUEST_TIMEOUT": self.config["global-request-timeout"],
+ "OSMMON_COLLECTOR_INTERVAL": self.config["collector-interval"],
+ "OSMMON_EVALUATOR_INTERVAL": self.config["evaluator-interval"],
+ # Kafka configuration
+ "OSMMON_MESSAGE_DRIVER": "kafka",
+ "OSMMON_MESSAGE_HOST": self.kafka.host,
+ "OSMMON_MESSAGE_PORT": self.kafka.port,
+ # Database configuration
+ "OSMMON_DATABASE_DRIVER": "mongo",
+ "OSMMON_DATABASE_URI": self.mongodb_client.connection_string,
+ "OSMMON_DATABASE_COMMONKEY": self.config["database-commonkey"],
+ # Prometheus/grafana configuration
+ "OSMMON_PROMETHEUS_URL": f"http://{self.prometheus_client.hostname}:{self.prometheus_client.port}",
+ "OSMMON_GRAFANA_URL": self.config["grafana-url"],
+ "OSMMON_GRAFANA_USER": self.config["grafana-user"],
+ "OSMMON_GRAFANA_PASSWORD": self.config["grafana-password"],
+ }
+ if self.vca.data:
+ environment["OSMMON_VCA_HOST"] = self.vca.data.endpoints
+ environment["OSMMON_VCA_SECRET"] = self.vca.secret
+ environment["OSMMON_VCA_USER"] = self.vca.user
+ environment["OSMMON_VCA_CACERT"] = self.vca.cacert
+ return {
+ "summary": "mon layer",
+ "description": "pebble config layer for mon",
+ "services": {
+ self.service_name: {
+ "override": "replace",
+ "summary": "mon service",
+ "command": "/bin/bash scripts/start.sh",
+ "startup": "enabled",
+ "user": "appuser",
+ "group": "appuser",
+ "environment": environment,
+ }
+ },
+ }
+
+ def _patch_k8s_service(self) -> None:
+ port = ServicePort(SERVICE_PORT, name=f"{self.app.name}")
+ self.service_patcher = KubernetesServicePatch(self, [port])
+
+
+if __name__ == "__main__": # pragma: no cover
+ main(OsmMonCharm)
--- /dev/null
+#!/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 KeystoneClient(BaseRelationClient):
+ """Requires side of a Keystone Endpoint"""
+
+ mandatory_fields = [
+ "host",
+ "port",
+ "user_domain_name",
+ "project_domain_name",
+ "username",
+ "password",
+ "service",
+ "keystone_db_password",
+ "region_id",
+ "admin_username",
+ "admin_password",
+ "admin_project_name",
+ ]
+
+ def __init__(self, charm: ops.charm.CharmBase, relation_name: str):
+ super().__init__(charm, relation_name, self.mandatory_fields)
+
+ @property
+ def host(self):
+ return self.get_data_from_app("host")
+
+ @property
+ def port(self):
+ return self.get_data_from_app("port")
+
+ @property
+ def user_domain_name(self):
+ return self.get_data_from_app("user_domain_name")
+
+ @property
+ def project_domain_name(self):
+ return self.get_data_from_app("project_domain_name")
+
+ @property
+ def username(self):
+ return self.get_data_from_app("username")
+
+ @property
+ def password(self):
+ return self.get_data_from_app("password")
+
+ @property
+ def service(self):
+ return self.get_data_from_app("service")
+
+ @property
+ def keystone_db_password(self):
+ return self.get_data_from_app("keystone_db_password")
+
+ @property
+ def region_id(self):
+ return self.get_data_from_app("region_id")
+
+ @property
+ def admin_username(self):
+ return self.get_data_from_app("admin_username")
+
+ @property
+ def admin_password(self):
+ return self.get_data_from_app("admin_password")
+
+ @property
+ def admin_project_name(self):
+ return self.get_data_from_app("admin_project_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"]]
+ )
+
+
+class PrometheusClient(BaseRelationClient):
+ """Requires side of a Prometheus Endpoint"""
+
+ mandatory_fields = ["hostname", "port"]
+
+ def __init__(self, charm: ops.charm.CharmBase, relation_name: str):
+ super().__init__(charm, relation_name, self.mandatory_fields)
+
+ @property
+ def hostname(self):
+ return self.get_data_from_app("hostname")
+
+ @property
+ def port(self):
+ return self.get_data_from_app("port")
+
+ @property
+ def user(self):
+ return self.get_data_from_app("user")
+
+ @property
+ def password(self):
+ return self.get_data_from_app("password")
--- /dev/null
+#!/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, OsmMonCharm, check_service_active
+
+container_name = "mon"
+service_name = "mon"
+
+
+@pytest.fixture
+def harness(mocker: MockerFixture):
+ mocker.patch("charm.KubernetesServicePatch", lambda x, y: None)
+ harness = Harness(OsmMonCharm)
+ 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", "prometheus", "keystone"]
+ )
+
+
+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 prometheus relation
+ relation_id = harness.add_relation("prometheus", "prometheus")
+ harness.add_relation_unit(relation_id, "prometheus/0")
+ harness.update_relation_data(
+ relation_id, "prometheus", {"hostname": "prometheus", "port": 9090}
+ )
+ relation_ids.append(relation_id)
+ # Add keystone relation
+ relation_id = harness.add_relation("keystone", "keystone")
+ harness.add_relation_unit(relation_id, "keystone/0")
+ harness.update_relation_data(
+ relation_id,
+ "keystone",
+ {
+ "host": "host",
+ "port": "port",
+ "user_domain_name": "user_domain_name",
+ "project_domain_name": "project_domain_name",
+ "username": "username",
+ "password": "password",
+ "service": "service",
+ "keystone_db_password": "keystone_db_password",
+ "region_id": "region_id",
+ "admin_username": "admin_username",
+ "admin_password": "admin_password",
+ "admin_project_name": "admin_project_name",
+ },
+ )
+ relation_ids.append(relation_id)
+ return relation_ids
--- /dev/null
+# 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}
projects / osm / devops.git / commitdiff