ruststream 0.7.5

Async messaging framework for Rust: broker-agnostic traits, router, codecs, and a conformance harness for broker authors.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

import React, {type ReactNode} from 'react';
import Translate from '@docusaurus/Translate';
import SectionHead from './SectionHead';
import shared from './landing.module.css';
import styles from './grid.module.css';
import CodeLink from './CodeLink';

interface Principle {
  title: ReactNode;
  body: ReactNode;
}

const PRINCIPLES: Principle[] = [
  {
    title: (
      <Translate id="landing.principles.agnostic.title">A core with no broker in it</Translate>
    ),
    body: (
      <Translate
        id="landing.principles.agnostic.body"
        values={{suite: <CodeLink api="ruststream/conformance/index.html">conformance</CodeLink>}}>
        {
          'The core is traits and types. Each broker is its own crate, held to the contract by the {suite} suite.'
        }
      </Translate>
    ),
  },
  {
    title: (
      <Translate id="landing.principles.config.title">
        Broker settings stay with the broker
      </Translate>
    ),
    body: (
      <Translate
        id="landing.principles.config.body"
        values={{config: <CodeLink to="/brokers/">Config</CodeLink>}}>
        {
          'Each broker crate owns its {config}. A client upgrade changes that crate, not the framework.'
        }
      </Translate>
    ),
  },
  {
    title: <Translate id="landing.principles.compile.title">Misuse does not compile</Translate>,
    body: (
      <Translate
        id="landing.principles.compile.body"
        values={{
          ack: (
            <CodeLink api="ruststream/trait.IncomingMessage.html#tymethod.ack">ack(self)</CodeLink>
          ),
        }}>
        {
          '{ack} consumes the delivery, so a second ack is a compile error. Out-of-order lifecycle calls fail the same way.'
        }
      </Translate>
    ),
  },
  {
    title: <Translate id="landing.principles.stream.title">Subscribers are streams</Translate>,
    body: (
      <Translate
        id="landing.principles.stream.body"
        values={{stream: <CodeLink api="ruststream/trait.Subscriber.html">Stream</CodeLink>}}>
        {
          'A subscriber is a {stream}, so back-pressure comes with it. The runtime builds handlers on top of it.'
        }
      </Translate>
    ),
  },
  {
    title: (
      <Translate id="landing.principles.generic.title">
        Generic, with no dyn in the contract
      </Translate>
    ),
    body: (
      <Translate
        id="landing.principles.generic.body"
        values={{
          rpitit: <CodeLink api="ruststream/trait.Broker.html">async fn in trait</CodeLink>,
        }}>
        {
          'The contract uses associated types and native {rpitit}. The runtime erases types only where a service needs it.'
        }
      </Translate>
    ),
  },
  {
    title: (
      <Translate id="landing.principles.capabilities.title">
        Capabilities, not a fat interface
      </Translate>
    ),
    body: (
      <Translate id="landing.principles.capabilities.body">
        Batches, transactions, request-reply, partitions and seeking are separate traits. A broker
        implements the ones it supports.
      </Translate>
    ),
  },
];

/** The design commitments, one per cell. */
export default function Principles(): ReactNode {
  return (
    <section className={shared.section} aria-labelledby="landing-principles">
      <SectionHead
        id="landing-principles"
        eyebrow={<Translate id="landing.principles.eyebrow">Design</Translate>}
        title={<Translate id="landing.principles.title">What the framework commits to</Translate>}
      />
      <ul className={styles.grid}>
        {PRINCIPLES.map((principle, index) => (
          <li key={index} className={styles.cell}>
            <span className={styles.index}>{String(index + 1).padStart(2, '0')}</span>
            <h3 className={styles.cellTitle}>{principle.title}</h3>
            <p className={styles.cellBody}>{principle.body}</p>
          </li>
        ))}
      </ul>
    </section>
  );
}