openstack/sunbeam-charms
Code Issues Proposed changes

Use new rabbitmq-k8s operator and interfaces

Browse Source 
Use renamed rabbitmq-k8s operator in bundles and the new rabbitmq
interface from the same operator in the codebase.

This will require an update to fetch-libs.sh for all charms
to rollout.

Change-Id: I53c8b9d1194895bdf6322cf8a256f32459aa76d7
This commit is contained in:
James Page 2022-10-13 10:06:19 +01:00
parent 6f0acf386c
commit ffb6177be5
6 changed files with 79 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ops-sunbeam/doc/bundles/full.yaml
View File

@ -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

2
ops-sunbeam/doc/bundles/minimal.yaml
View File

@ -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

2
ops-sunbeam/fetch-libs.sh
View File

@ -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

2
ops-sunbeam/ops_sunbeam/charm.py
View File

@ -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,

14
ops-sunbeam/ops_sunbeam/relation_handlers.py
View File

@ -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."""

133
ops-sunbeam/unit_tests/lib/charms/sunbeam_rabbitmq_operator/v0/amqp.py → ops-sunbeam/unit_tests/lib/charms/rabbitmq_k8s/v0/rabbitmq.py
View File

@ -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")