Messages — Fedora Messaging 1.1.0 documentation

# Messages

Before you release your application, you should create a subclass of `fedora_messaging.message.Message`, define a schema, define a default severity, and implement some methods.

## Schema

Defining a message schema is important for several reasons.

First and foremost, if will help you (the developer) ensure you don’t accidentally change your message’s format. When messages are being generated from, say, a database object, it’s easy to make a schema change to the database and unintentionally alter your message, which breaks consumers of your message. Without a schema, you might not catch this until you deploy your application and consumers start crashing. With a schema, you’ll get an error as you develop!

Secondly, it allows you to change your message format in a controlled fashion by versioning your schema. You can then choose to implement methods one way or another based on the version of the schema used by a message.

Message schema are defined using JSON Schema.

### Header Schema

The default header schema declares that the header field must be a JSON object with several expected keys. You can leave the schema as-is when you define your own message, or you can refine it. The base schema will always be enforced in addition to your custom schema.

### Body Schema

The default body schema simply declares that the header field must be a JSON object.

### Example Schema

    # Copyright (C) 2018  Red Hat, Inc.
    #
    # This program is free software; you can redistribute it and/or modify
    # it under the terms of the GNU General Public License as published by
    # the Free Software Foundation; either version 2 of the License, or
    # (at your option) any later version.
    #
    # This program is distributed in the hope that it will be useful,
    # but WITHOUT ANY WARRANTY; without even the implied warranty of
    # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    # GNU General Public License for more details.
    #
    # You should have received a copy of the GNU General Public License along
    # with this program; if not, write to the Free Software Foundation, Inc.,
    # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
    """This is an example of a message schema."""

    from fedora_messaging import message
    from .utils import get_avatar

    class BaseMessage(message.Message):
        """
        You should create a super class that each schema version inherits from.
        This lets consumers perform ``isinstance(msg, BaseMessage)`` if they are
        receiving multiple message types and allows the publisher to change the
        schema as long as they preserve the Python API.
        """

        def __str__(self):
            """Return a complete human-readable representation of the message."""
            return "Subject: {subj}\n{body}\n".format(subj=self.subject, body=self.body)

        @property
        def summary(self):
            """Return a summary of the message."""
            return self.subject

        @property
        def subject(self):
            """The email's subject."""
            return 'Message did not implement "subject" property'

        @property
        def body(self):
            """The email message body."""
            return 'Message did not implement "body" property'

        @property
        def url(self):
            """An URL to the email in HyperKitty

            Returns:
                str or None: A relevant URL.
            """
            base_url = "https://lists.fedoraproject.org/archives"
            archived_at = self._get_archived_at()
            if archived_at and archived_at.startswith("<"):
                archived_at = archived_at[1:]
            if archived_at and archived_at.endswith(">"):
                archived_at = archived_at[:-1]
            if archived_at and archived_at.startswith("http"):
                return archived_at
            elif archived_at:
                return base_url + archived_at
            else:
                return None

        @property
        def app_icon(self):
            """An URL to the icon of the application that generated the message."""
            return "https://apps.fedoraproject.org/img/icons/hyperkitty.png"

        @property
        def usernames(self):
            """List of users affected by the action that generated this message."""
            return []

        @property
        def packages(self):
            """List of packages affected by the action that generated this message."""
            return []

    class MessageV1(BaseMessage):
        """
        A sub-class of a Fedora message that defines a message schema for messages
        published by Mailman when it receives mail to send out.
        """

        body_schema = {
            "id": "http://fedoraproject.org/message-schema/mailman#",
            "$schema": "http://json-schema.org/draft-04/schema#",
            "description": "Schema for message sent to mailman",
            "type": "object",
            "properties": {
                "mlist": {
                    "type": "object",
                    "properties": {
                        "list_name": {
                            "type": "string",
                            "description": "The name of the mailing list",
                        }
                    },
                },
                "msg": {
                    "description": "An object representing the email",
                    "type": "object",
                    "properties": {
                        "delivered-to": {"type": "string"},
                        "from": {"type": "string"},
                        "cc": {"type": "string"},
                        "to": {"type": "string"},
                        "x-mailman-rule-hits": {"type": "string"},
                        "x-mailman-rule-misses": {"type": "string"},
                        "x-message-id-hash": {"type": "string"},
                        "references": {"type": "string"},
                        "in-reply-to": {"type": "string"},
                        "message-id": {"type": "string"},
                        "archived-at": {"type": "string"},
                        "subject": {"type": "string"},
                        "body": {"type": "string"},
                    },
                    "required": ["from", "to", "subject", "body"],
                },
            },
            "required": ["mlist", "msg"],
        }

        @property
        def subject(self):
            """The email's subject."""
            return self._body["msg"]["subject"]

        @property
        def body(self):
            """The email message body."""
            return self._body["msg"]["body"]

        @property
        def agent_avatar(self):
            """An URL to the avatar of the user who caused the action."""
            from_header = self._body["msg"]["from"]
            return get_avatar(from_header)

        def _get_archived_at(self):
            return self._body["msg"]["archived-at"]

    class MessageV2(BaseMessage):
        """
        This is a revision from the MessageV1 schema which flattens the message
        structure into a single object, but is backwards compatible for any users
        that make use of the properties (``subject`` and ``body``).
        """

        body_schema = {
            "id": "http://fedoraproject.org/message-schema/mailman#",
            "$schema": "http://json-schema.org/draft-04/schema#",
            "description": "Schema for message sent to mailman",
            "type": "object",
            "required": ["mailing_list", "from", "to", "subject", "body"],
            "properties": {
                "mailing_list": {
                    "type": "string",
                    "description": "The name of the mailing list",
                },
                "delivered-to": {"type": "string"},
                "from": {"type": "string"},
                "cc": {"type": "string"},
                "to": {"type": "string"},
                "x-mailman-rule-hits": {"type": "string"},
                "x-mailman-rule-misses": {"type": "string"},
                "x-message-id-hash": {"type": "string"},
                "references": {"type": "string"},
                "in-reply-to": {"type": "string"},
                "message-id": {"type": "string"},
                "archived-at": {"type": "string"},
                "subject": {"type": "string"},
                "body": {"type": "string"},
            },
        }

        @property
        def subject(self):
            """The email's subject."""
            return self._body["subject"]

        @property
        def body(self):
            """The email message body."""
            return self._body["body"]

        @property
        def agent_avatar(self):
            """An URL to the avatar of the user who caused the action."""
            from_header = self._body["from"]
            return get_avatar(from_header)

        def _get_archived_at(self):
            return self._body["archived-at"]

Note that message schema can be composed of other message schema, and validation of fields can be much more detailed than just a simple type check. Consult the JSON Schema documentation for complete details.

## Message Conventions

### Schema are Immutable

Message schema should be treated as immutable. Once defined, they should not be altered. Instead, define a new schema class, mark the old one as deprecated, and remove it after an appropriate transition period.

### Provide Accessors

The JSON schema ensures the message sent “on the wire” conforms to a particular format. Messages should provide Python properties to access the deserialized JSON object. This Python API should maintain backwards compatibility between schema. This shields consumers from changes in schema.

## Packaging

Finally, you must distribute your schema to clients. It is recommended that you maintain your message schema in your application’s git repository in a separate Python package. The package name should be `<your-app-name>_schema`.

A complete sample schema package can be found in the fedora-messaging repository. This includes unit tests, the schema classes, and a setup.py. You can adapt this boilerplate with the following steps:

- Change the package name from `mailman_schema` to `<your-app-name>_schema` in `setup.py`.
- Rename the `mailman_schema` directory to `<your-app-name>_schema`.
- Add your schema classes to `schema.py` and tests to `tests/test_schema.py`.
- Update the `README` file.
- Build the distribution with `python setup.py sdist bdist_wheel`.
- Upload the sdist and wheel to PyPI with `twine`.
- Submit an RPM package for it to Fedora and EPEL.