tracker

3.4 KB

1. \* hl:smtp — the SMTP submission client.
3. import { Mailer } from 'hl:smtp'
4. m = new Mailer('mail.example.com', 587, {
5. user = '[email protected]'
6. pass = '…'
7. from = '[email protected]'
8. })
9. m.send({ to = '[email protected]' subject = 'Hello' text = 'Hi' })
11. Non-blocking: send() answers a job id, the OUTCOME arrives later — drain
12. it with `for (r of m.results())`, or deliver() it as the declared events
13. below while the program keeps running. *\
15. /* The first three declared properties ARE the positional signature (SPEC.md
16. "The file root is the constructor"), so `new Mailer(host, port, options)`
17. reads as written. */
19. \* One send was ACCEPTED by the server. r = { id, ok, code, stage, message,
20. secure, to }. *\
21. emit sent(
22. Hybrid r \\ the result record for one message
23. )
25. \* One send FAILED — refused, TLS problem, timeout. Same record shape;
26. `stage` names where it died. *\
27. emit failed(
28. Hybrid r \\ the result record for one message
29. )
31. String host = "127.0.0.1" \\ the submission server
32. Number port = 587 \\ 587 STARTTLS, 465 implicit TLS
33. Hybrid options = null \\ { user, pass, from, … } — credentials and defaults
35. \* The plugin's handle for this mailer — set by the run body; a send() before
36. construction finished is impossible, the root IS the constructor. *\
37. Number handle = 0
39. \* SEND — non-blocking. Validated and rendered HERE, on this thread, so a
40. refusal (a line break in to/subject, a missing recipient, an address
41. without an @) is a located error at YOUR line, through `on Error` like any
42. plugin failure. Answers the job id; the outcome arrives on the result
43. source. msg: { to (String or list), subject, text, html, from }. *\
44. send(
45. Hybrid msg \\ the message — to/subject/text/html/from
46. ) {
47. return __native("smtp.send", handle, msg)
48. }
50. \* THE RESULT SOURCE, drained: `for (r of m.results())` yields one result per
51. accepted send and ENDS when every send is answered — which is what lets a
52. script that only sends mail terminate. *\
53. results() {
54. return __native("smtp.results", handle)
55. }
57. \* THE RESULT SOURCE, delivered: results arrive as the declared sent/failed
58. events while the program goes on — a server keeps serving with mail in
59. flight. Use this OR results(), never both: they take from one queue. *\
60. deliver() {
61. __native("smtp.mark_registered", handle)
62. __native("eventloop.register", __native("smtp.results", handle), "mail")
63. }
65. \* How many sends have not been answered yet. *\
66. pending() {
67. return __native("smtp.pending", handle)
68. }
70. \* Stop the sender thread. A job already in conversation finishes. *\
71. close() {
72. __native("smtp.close", handle)
73. handle = 0
74. }
76. // The split every caller of deliver() wants: one event per outcome. `mail`
77. // is delivered at THIS instance by the loop, and the re-emit dispatches at
78. // it too, so an instance-scoped `on m.sent(r)` in the constructing program
79. // hears it.
80. on mail(r) {
81. if (r.ok == true) {
82. emit sent(r)
83. } else {
84. emit failed(r)
85. }
86. }
88. // Open the mailer and start its sender thread. A METHOD, called from the run
89. // body — never a root assignment: a bare `handle = …` at the root would be a
90. // property INITIALIZER, and initializers run BEFORE positional args bind
91. // (construction order 1 vs 4) — it would open a mailer for the DEFAULT host.
92. // Same shape as hl:http1's listen().
93. open() {
94. handle = __native("smtp.open", host, port, options)
95. }
97. // Run body — the constructor's last act.
98. open()