diff --git a/ops-sunbeam/doc/bundles/full.yaml b/ops-sunbeam/doc/bundles/full.yaml index c873210f..6d0c956b 100644 --- a/ops-sunbeam/doc/bundles/full.yaml +++ b/ops-sunbeam/doc/bundles/full.yaml @@ -18,7 +18,7 @@ applications: scale: 1 trust: false rabbitmq: - charm: ch:sunbeam-rabbitmq-operator + charm: ch:rabbitmq-k8s channel: edge scale: 1 trust: true diff --git a/ops-sunbeam/doc/bundles/minimal.yaml b/ops-sunbeam/doc/bundles/minimal.yaml index 8573791c..ee8e6eec 100644 --- a/ops-sunbeam/doc/bundles/minimal.yaml +++ b/ops-sunbeam/doc/bundles/minimal.yaml @@ -19,7 +19,7 @@ applications: scale: 1 trust: false rabbitmq: - charm: ch:sunbeam-rabbitmq-operator + charm: ch:rabbitmq-k8s channel: edge scale: 1 trust: true diff --git a/ops-sunbeam/fetch-libs.sh b/ops-sunbeam/fetch-libs.sh index e4e15500..c009b657 100755 --- a/ops-sunbeam/fetch-libs.sh +++ b/ops-sunbeam/fetch-libs.sh @@ -8,7 +8,7 @@ charmcraft fetch-lib charms.nginx_ingress_integrator.v0.ingress charmcraft fetch-lib charms.data_platform_libs.v0.database_requires charmcraft fetch-lib charms.sunbeam_keystone_operator.v0.identity_service charmcraft fetch-lib charms.keystone_k8s.v0.cloud_credentials -charmcraft fetch-lib charms.sunbeam_rabbitmq_operator.v0.amqp +charmcraft fetch-lib charms.rabbitmq_k8s.v0.rabbitmq charmcraft fetch-lib charms.sunbeam_ovn_central_operator.v0.ovsdb charmcraft fetch-lib charms.observability_libs.v0.kubernetes_service_patch charmcraft fetch-lib charms.traefik_k8s.v1.ingress diff --git a/ops-sunbeam/ops_sunbeam/charm.py b/ops-sunbeam/ops_sunbeam/charm.py index c868280a..3c482783 100644 --- a/ops-sunbeam/ops_sunbeam/charm.py +++ b/ops-sunbeam/ops_sunbeam/charm.py @@ -95,7 +95,7 @@ class OSBaseOperatorCharm(ops.charm.CharmBase): """Relation handlers for the service.""" handlers = handlers or [] if self.can_add_handler("amqp", handlers): - self.amqp = sunbeam_rhandlers.AMQPHandler( + self.amqp = sunbeam_rhandlers.RabbitMQHandler( self, "amqp", self.configure_charm, diff --git a/ops-sunbeam/ops_sunbeam/relation_handlers.py b/ops-sunbeam/ops_sunbeam/relation_handlers.py index 595141ad..5c90aa86 100644 --- a/ops-sunbeam/ops_sunbeam/relation_handlers.py +++ b/ops-sunbeam/ops_sunbeam/relation_handlers.py @@ -308,8 +308,8 @@ class DBHandler(RelationHandler): } -class AMQPHandler(RelationHandler): - """Handler for managing a amqp relation.""" +class RabbitMQHandler(RelationHandler): + """Handler for managing a rabbitmq relation.""" DEFAULT_PORT = "5672" @@ -332,8 +332,8 @@ class AMQPHandler(RelationHandler): logger.debug("Setting up AMQP event handler") # Lazy import to ensure this lib is only required if the charm # has this relation. - import charms.sunbeam_rabbitmq_operator.v0.amqp as sunbeam_amqp - amqp = sunbeam_amqp.AMQPRequires( + import charms.rabbitmq_k8s.v0.rabbitmq as sunbeam_rabbitmq + amqp = sunbeam_rabbitmq.RabbitMQRequires( self.charm, self.relation_name, self.username, self.vhost ) self.framework.observe(amqp.on.ready, self._on_amqp_ready) @@ -383,6 +383,12 @@ class AMQPHandler(RelationHandler): return ctxt +class AMQPHandler(RabbitMQHandler): + """Backwards compatibility class for older library consumers.""" + + pass + + class IdentityServiceRequiresHandler(RelationHandler): """Handler for managing a identity-service relation.""" diff --git a/ops-sunbeam/unit_tests/lib/charms/sunbeam_rabbitmq_operator/v0/amqp.py b/ops-sunbeam/unit_tests/lib/charms/rabbitmq_k8s/v0/rabbitmq.py similarity index 62% rename from ops-sunbeam/unit_tests/lib/charms/sunbeam_rabbitmq_operator/v0/amqp.py rename to ops-sunbeam/unit_tests/lib/charms/rabbitmq_k8s/v0/rabbitmq.py index 84b0b5a2..c7df2409 100644 --- a/ops-sunbeam/unit_tests/lib/charms/sunbeam_rabbitmq_operator/v0/amqp.py +++ b/ops-sunbeam/unit_tests/lib/charms/rabbitmq_k8s/v0/rabbitmq.py @@ -1,10 +1,9 @@ -"""AMQPProvides and Requires module. - +"""RabbitMQProvides and Requires module. This library contains the Requires and Provides classes for handling -the amqp interface. +the rabbitmq interface. -Import `AMQPRequires` in your charm, with the charm object and the +Import `RabbitMQRequires` in your charm, with the charm object and the relation name: - self - "amqp" @@ -21,13 +20,13 @@ Two events are also available to respond to: A basic example showing the usage of this relation follows: ``` -from charms.sunbeam_rabbitmq_operator.v0.amqp import AMQPRequires +from charms.rabbitmq_k8s.v0.rabbitmq import RabbitMQRequires -class AMQPClientCharm(CharmBase): +class RabbitMQClientCharm(CharmBase): def __init__(self, *args): super().__init__(*args) - # AMQP Requires - self.amqp = AMQPRequires( + # RabbitMQ Requires + self.amqp = RabbitMQRequires( self, "amqp", username="myusername", vhost="vhostname" @@ -40,42 +39,42 @@ class AMQPClientCharm(CharmBase): self.amqp.on.goneaway, self._on_amqp_goneaway) def _on_amqp_connected(self, event): - '''React to the AMQP connected event. + '''React to the RabbitMQ connected event. - This event happens when n AMQP relation is added to the + This event happens when n RabbitMQ relation is added to the model before credentials etc have been provided. ''' # Do something before the relation is complete pass def _on_amqp_ready(self, event): - '''React to the AMQP ready event. + '''React to the RabbitMQ ready event. - The AMQP interface will use the provided username and vhost for the + The RabbitMQ interface will use the provided username and vhost for the request to the rabbitmq server. ''' - # AMQP Relation is ready. Do something with the completed relation. + # RabbitMQ Relation is ready. Do something with the completed relation. pass def _on_amqp_goneaway(self, event): - '''React to the AMQP goneaway event. + '''React to the RabbitMQ goneaway event. - This event happens when an AMQP relation is removed. + This event happens when an RabbitMQ relation is removed. ''' - # AMQP Relation has goneaway. shutdown services or suchlike + # RabbitMQ Relation has goneaway. shutdown services or suchlike pass ``` """ # The unique Charmhub library identifier, never change it -LIBID = "ab1414b6baf044f099caf9c117f1a101" +LIBID = "45622352791142fd9cf87232e3bd6f2a" # 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 +LIBPATCH = 1 import logging @@ -94,39 +93,38 @@ from typing import List logger = logging.getLogger(__name__) -class AMQPConnectedEvent(EventBase): - """AMQP connected Event.""" +class RabbitMQConnectedEvent(EventBase): + """RabbitMQ connected Event.""" pass -class AMQPReadyEvent(EventBase): - """AMQP ready for use Event.""" +class RabbitMQReadyEvent(EventBase): + """RabbitMQ ready for use Event.""" pass -class AMQPGoneAwayEvent(EventBase): - """AMQP relation has gone-away Event""" +class RabbitMQGoneAwayEvent(EventBase): + """RabbitMQ relation has gone-away Event""" pass -class AMQPServerEvents(ObjectEvents): +class RabbitMQServerEvents(ObjectEvents): """Events class for `on`""" - connected = EventSource(AMQPConnectedEvent) - ready = EventSource(AMQPReadyEvent) - goneaway = EventSource(AMQPGoneAwayEvent) + connected = EventSource(RabbitMQConnectedEvent) + ready = EventSource(RabbitMQReadyEvent) + goneaway = EventSource(RabbitMQGoneAwayEvent) -class AMQPRequires(Object): +class RabbitMQRequires(Object): """ - AMQPRequires class + RabbitMQRequires class """ - on = AMQPServerEvents() - _stored = StoredState() + on = RabbitMQServerEvents() def __init__(self, charm, relation_name: str, username: str, vhost: str): super().__init__(charm, relation_name) @@ -152,89 +150,88 @@ class AMQPRequires(Object): ) def _on_amqp_relation_joined(self, event): - """AMQP relation joined.""" - logging.debug("RabbitMQAMQPRequires on_joined") + """RabbitMQ relation joined.""" + logging.debug("RabbitMQRabbitMQRequires on_joined") self.on.connected.emit() self.request_access(self.username, self.vhost) def _on_amqp_relation_changed(self, event): - """AMQP relation changed.""" - logging.debug("RabbitMQAMQPRequires on_changed/departed") + """RabbitMQ relation changed.""" + logging.debug("RabbitMQRabbitMQRequires on_changed/departed") if self.password: self.on.ready.emit() def _on_amqp_relation_broken(self, event): - """AMQP relation broken.""" - logging.debug("RabbitMQAMQPRequires on_broken") + """RabbitMQ relation broken.""" + logging.debug("RabbitMQRabbitMQRequires on_broken") self.on.goneaway.emit() @property def _amqp_rel(self) -> Relation: - """The AMQP relation.""" + """The RabbitMQ relation.""" return self.framework.model.get_relation(self.relation_name) @property def password(self) -> str: - """Return the AMQP password from the server side of the relation.""" + """Return the RabbitMQ password from the server side of the relation.""" return self._amqp_rel.data[self._amqp_rel.app].get("password") @property def hostname(self) -> str: - """Return the hostname from the AMQP relation""" + """Return the hostname from the RabbitMQ relation""" return self._amqp_rel.data[self._amqp_rel.app].get("hostname") @property def ssl_port(self) -> str: - """Return the SSL port from the AMQP relation""" + """Return the SSL port from the RabbitMQ relation""" return self._amqp_rel.data[self._amqp_rel.app].get("ssl_port") @property def ssl_ca(self) -> str: - """Return the SSL port from the AMQP relation""" + """Return the SSL port from the RabbitMQ relation""" return self._amqp_rel.data[self._amqp_rel.app].get("ssl_ca") @property def hostnames(self) -> List[str]: - """Return a list of remote RMQ hosts from the AMQP relation""" + """Return a list of remote RMQ hosts from the RabbitMQ relation""" _hosts = [] for unit in self._amqp_rel.units: _hosts.append(self._amqp_rel.data[unit].get("ingress-address")) return _hosts def request_access(self, username: str, vhost: str) -> None: - """Request access to the AMQP server.""" + """Request access to the RabbitMQ server.""" if self.model.unit.is_leader(): - logging.debug("Requesting AMQP user and vhost") + logging.debug("Requesting RabbitMQ user and vhost") self._amqp_rel.data[self.charm.app]["username"] = username self._amqp_rel.data[self.charm.app]["vhost"] = vhost -class HasAMQPClientsEvent(EventBase): - """Has AMQPClients Event.""" +class HasRabbitMQClientsEvent(EventBase): + """Has RabbitMQClients Event.""" pass -class ReadyAMQPClientsEvent(EventBase): - """AMQPClients Ready Event.""" +class ReadyRabbitMQClientsEvent(EventBase): + """RabbitMQClients Ready Event.""" pass -class AMQPClientEvents(ObjectEvents): +class RabbitMQClientEvents(ObjectEvents): """Events class for `on`""" - has_amqp_clients = EventSource(HasAMQPClientsEvent) - ready_amqp_clients = EventSource(ReadyAMQPClientsEvent) + has_amqp_clients = EventSource(HasRabbitMQClientsEvent) + ready_amqp_clients = EventSource(ReadyRabbitMQClientsEvent) -class AMQPProvides(Object): +class RabbitMQProvides(Object): """ - AMQPProvides class + RabbitMQProvides class """ - on = AMQPClientEvents() - _stored = StoredState() + on = RabbitMQClientEvents() def __init__(self, charm, relation_name, callback): super().__init__(charm, relation_name) @@ -255,35 +252,35 @@ class AMQPProvides(Object): ) def _on_amqp_relation_joined(self, event): - """Handle AMQP joined.""" - logging.debug("RabbitMQAMQPProvides on_joined data={}" - .format(event.relation.data)) + """Handle RabbitMQ joined.""" + logging.debug("RabbitMQRabbitMQProvides on_joined data={}" + .format(event.relation.data[event.relation.app])) self.on.has_amqp_clients.emit() def _on_amqp_relation_changed(self, event): - """Handle AMQP changed.""" - logging.debug("RabbitMQAMQPProvides on_changed data={}" - .format(event.relation.data)) + """Handle RabbitMQ changed.""" + logging.debug("RabbitMQRabbitMQProvides on_changed data={}" + .format(event.relation.data[event.relation.app])) # Validate data on the relation if self.username(event) and self.vhost(event): self.on.ready_amqp_clients.emit() if self.charm.unit.is_leader(): self.callback(event, self.username(event), self.vhost(event)) else: - logging.warning("Received AMQP changed event without the " + logging.warning("Received RabbitMQ changed event without the " "expected keys ('username', 'vhost') in the " "application data bag. Incompatible charm in " "other end of relation?") def _on_amqp_relation_broken(self, event): - """Handle AMQP broken.""" - logging.debug("RabbitMQAMQPProvides on_departed") + """Handle RabbitMQ broken.""" + logging.debug("RabbitMQRabbitMQProvides on_departed") # TODO clear data on the relation def username(self, event): - """Return the AMQP username from the client side of the relation.""" + """Return the RabbitMQ username from the client side of the relation.""" return event.relation.data[event.relation.app].get("username") def vhost(self, event): - """Return the AMQP vhost from the client side of the relation.""" + """Return the RabbitMQ vhost from the client side of the relation.""" return event.relation.data[event.relation.app].get("vhost")