1use crate::{
2 models::{InsertQueryBuilder, UpdateQueryBuilder},
3 prelude::*,
4 tunnel::{MAX_SERVER_IDX, TunnelProtocol},
5};
6use garde::Validate;
7use serde::{Deserialize, Serialize};
8use sqlx::{Row, postgres::PgRow};
9use std::{
10 collections::{BTreeMap, HashMap, HashSet},
11 sync::{Arc, LazyLock},
12};
13use utoipa::ToSchema;
14
15const ADVISORY_LOCK_IDX: i64 = 0x7475_6e6e_656c_0001;
16
17fn validate_name(name: &compact_str::CompactString, _context: &()) -> Result<(), garde::Error> {
18 if name.is_empty() || name.len() > 63 {
19 return Err(garde::Error::new("name must be 1 to 63 characters"));
20 }
21
22 if !name
23 .bytes()
24 .all(|byte| byte.is_ascii_lowercase() || byte.is_ascii_digit() || byte == b'-')
25 {
26 return Err(garde::Error::new(
27 "name must only contain lowercase letters, digits and dashes",
28 ));
29 }
30
31 if name.starts_with('-') || name.ends_with('-') {
32 return Err(garde::Error::new("name must not start or end with a dash"));
33 }
34
35 if crate::tunnel::is_alias_shaped(name) {
36 return Err(garde::Error::new(
37 "name must not be eight hexadecimal characters, which is reserved for the address every server keeps",
38 ));
39 }
40
41 Ok(())
42}
43
44pub fn validate_optional_name(
45 name: &Option<compact_str::CompactString>,
46 context: &(),
47) -> Result<(), garde::Error> {
48 match name {
49 Some(name) => validate_name(name, context),
50 None => Ok(()),
51 }
52}
53
54fn validate_protocols(
55 protocols: &HashSet<TunnelProtocol>,
56 _context: &(),
57) -> Result<(), garde::Error> {
58 if protocols.is_empty() {
59 return Err(garde::Error::new("at least one protocol is required"));
60 }
61
62 Ok(())
63}
64
65#[derive(Serialize, Deserialize)]
66pub struct ServerTunnel {
67 pub server: Fetchable<super::server::Server>,
68
69 pub idx: u16,
70 pub name: compact_str::CompactString,
71
72 pub created: chrono::NaiveDateTime,
73
74 extension_data: super::ModelExtensionData,
75}
76
77impl BaseModel for ServerTunnel {
78 const NAME: &'static str = "server_tunnel";
79
80 fn get_extension_list() -> &'static super::ModelExtensionList {
81 static EXTENSIONS: LazyLock<super::ModelExtensionList> =
82 LazyLock::new(|| parking_lot::RwLock::new(Vec::new()));
83
84 &EXTENSIONS
85 }
86
87 fn get_extension_data(&self) -> &super::ModelExtensionData {
88 &self.extension_data
89 }
90
91 #[inline]
92 fn base_columns(prefix: Option<&str>) -> BTreeMap<&'static str, compact_str::CompactString> {
93 let prefix = prefix.unwrap_or_default();
94
95 BTreeMap::from([
96 (
97 "server_tunnels.server_uuid",
98 compact_str::format_compact!("{prefix}server_uuid"),
99 ),
100 (
101 "server_tunnels.idx",
102 compact_str::format_compact!("{prefix}idx"),
103 ),
104 (
105 "server_tunnels.name",
106 compact_str::format_compact!("{prefix}name"),
107 ),
108 (
109 "server_tunnels.created",
110 compact_str::format_compact!("{prefix}created"),
111 ),
112 ])
113 }
114
115 #[inline]
116 fn map(prefix: Option<&str>, row: &PgRow) -> Result<Self, crate::database::DatabaseError> {
117 let prefix = prefix.unwrap_or_default();
118
119 Ok(Self {
120 server: super::server::Server::get_fetchable(
121 row.try_get(compact_str::format_compact!("{prefix}server_uuid").as_str())?,
122 ),
123 idx: row.try_get::<i32, _>(compact_str::format_compact!("{prefix}idx").as_str())?
124 as u16,
125 name: row.try_get(compact_str::format_compact!("{prefix}name").as_str())?,
126 created: row.try_get(compact_str::format_compact!("{prefix}created").as_str())?,
127 extension_data: Self::map_extensions(prefix, row)?,
128 })
129 }
130}
131
132impl ServerTunnel {
133 pub async fn by_server_uuid(
134 database: &crate::database::Database,
135 server_uuid: uuid::Uuid,
136 ) -> Result<Option<Self>, crate::database::DatabaseError> {
137 let row = sqlx::query(sqlx::AssertSqlSafe(format!(
138 r#"
139 SELECT {}
140 FROM server_tunnels
141 WHERE server_tunnels.server_uuid = $1
142 "#,
143 Self::columns_sql(None)
144 )))
145 .bind(server_uuid)
146 .fetch_optional(database.read())
147 .await?;
148
149 row.try_map(|row| Self::map(None, &row))
150 }
151
152 async fn allocate_idx(
153 transaction: &mut sqlx::Transaction<'_, sqlx::Postgres>,
154 ) -> Result<i32, crate::database::DatabaseError> {
155 sqlx::query("SELECT pg_advisory_xact_lock($1)")
156 .bind(ADVISORY_LOCK_IDX)
157 .execute(&mut **transaction)
158 .await?;
159
160 let idx: Option<i32> = sqlx::query_scalar(
161 r#"
162 SELECT candidate.idx
163 FROM generate_series(0, $1) AS candidate(idx)
164 WHERE NOT EXISTS (
165 SELECT 1 FROM server_tunnels WHERE server_tunnels.idx = candidate.idx
166 )
167 ORDER BY candidate.idx
168 LIMIT 1
169 "#,
170 )
171 .bind(i32::from(MAX_SERVER_IDX))
172 .fetch_optional(&mut **transaction)
173 .await?;
174
175 idx.ok_or_else(|| {
176 crate::database::DatabaseError::Any(anyhow::anyhow!(
177 "the tunnel network is full, no frontend index is available"
178 ))
179 })
180 }
181
182 pub async fn ports(
183 &self,
184 database: &crate::database::Database,
185 ) -> Result<Vec<ServerTunnelPort>, crate::database::DatabaseError> {
186 ServerTunnelPort::by_server_uuid(database, self.server.uuid).await
187 }
188
189 pub fn suggest_name(server_name: &str) -> compact_str::CompactString {
190 let mut base = String::with_capacity(server_name.len());
191 for character in server_name.chars() {
192 match character {
193 'a'..='z' | '0'..='9' => base.push(character),
194 'A'..='Z' => base.push(character.to_ascii_lowercase()),
195 _ if !base.ends_with('-') => base.push('-'),
196 _ => {}
197 }
198 }
199
200 let base: String = base.trim_matches('-').chars().take(58).collect();
201 let base = base.trim_matches('-');
202 let base = if base.is_empty() { "server" } else { base };
203
204 if crate::tunnel::is_alias_shaped(base) {
205 compact_str::format_compact!("{base}-1")
206 } else {
207 base.into()
208 }
209 }
210}
211
212#[derive(ToSchema, Serialize, Deserialize)]
213pub struct ServerTunnelPort {
214 pub port: u16,
215 pub protocols: HashSet<TunnelProtocol>,
216
217 pub created: chrono::DateTime<chrono::Utc>,
218}
219
220impl ServerTunnelPort {
221 pub async fn by_server_uuid(
222 database: &crate::database::Database,
223 server_uuid: uuid::Uuid,
224 ) -> Result<Vec<Self>, crate::database::DatabaseError> {
225 sqlx::query(
226 r#"
227 SELECT server_tunnel_ports.port, server_tunnel_ports.protocols, server_tunnel_ports.created
228 FROM server_tunnel_ports
229 WHERE server_tunnel_ports.server_uuid = $1
230 ORDER BY server_tunnel_ports.port
231 "#,
232 )
233 .bind(server_uuid)
234 .fetch_all(database.read())
235 .await?
236 .into_iter()
237 .map(|row| {
238 Ok(Self {
239 port: row.try_get::<i32, _>("port")? as u16,
240 protocols: row
241 .try_get::<Vec<TunnelProtocol>, _>("protocols")?
242 .into_iter()
243 .collect(),
244 created: row.try_get::<chrono::NaiveDateTime, _>("created")?.and_utc(),
245 })
246 })
247 .try_collect_vec()
248 }
249
250 pub async fn by_server_uuids(
251 database: &crate::database::Database,
252 server_uuids: &[uuid::Uuid],
253 ) -> Result<HashMap<uuid::Uuid, Vec<Self>>, crate::database::DatabaseError> {
254 let mut ports: HashMap<uuid::Uuid, Vec<Self>> = HashMap::new();
255
256 for row in sqlx::query(
257 r#"
258 SELECT server_tunnel_ports.server_uuid, server_tunnel_ports.port, server_tunnel_ports.protocols, server_tunnel_ports.created
259 FROM server_tunnel_ports
260 WHERE server_tunnel_ports.server_uuid = ANY($1)
261 ORDER BY server_tunnel_ports.port
262 "#,
263 )
264 .bind(server_uuids)
265 .fetch_all(database.read())
266 .await?
267 {
268 ports
269 .entry(row.try_get("server_uuid")?)
270 .or_default()
271 .push(Self {
272 port: row.try_get::<i32, _>("port")? as u16,
273 protocols: row
274 .try_get::<Vec<TunnelProtocol>, _>("protocols")?
275 .into_iter()
276 .collect(),
277 created: row.try_get::<chrono::NaiveDateTime, _>("created")?.and_utc(),
278 });
279 }
280
281 Ok(ports)
282 }
283
284 pub async fn replace(
285 database: &crate::database::Database,
286 server_uuid: uuid::Uuid,
287 ports: &[CreateServerTunnelPortOptions],
288 ) -> Result<(), crate::database::DatabaseError> {
289 for port in ports {
290 port.validate()?;
291 }
292
293 let mut transaction = database.write().begin().await?;
294
295 sqlx::query("DELETE FROM server_tunnel_ports WHERE server_tunnel_ports.server_uuid = $1")
296 .bind(server_uuid)
297 .execute(&mut *transaction)
298 .await?;
299
300 for port in ports {
301 sqlx::query(
302 r#"
303 INSERT INTO server_tunnel_ports (server_uuid, port, protocols)
304 VALUES ($1, $2, $3)
305 ON CONFLICT (server_uuid, port) DO UPDATE SET protocols = EXCLUDED.protocols
306 "#,
307 )
308 .bind(server_uuid)
309 .bind(i32::from(port.port))
310 .bind(port.protocols.iter().copied().collect::<Vec<_>>())
311 .execute(&mut *transaction)
312 .await?;
313 }
314
315 crate::tunnel::bump_epoch(&mut *transaction).await?;
316 transaction.commit().await?;
317
318 Ok(())
319 }
320}
321
322#[derive(ToSchema, Serialize)]
323#[schema(title = "ServerTunnelPeer")]
324pub struct ServerTunnelPeer {
325 pub server_uuid: uuid::Uuid,
326 pub server_name: compact_str::CompactString,
327
328 pub name: compact_str::CompactString,
329 pub alias: compact_str::CompactString,
330 pub address: Option<compact_str::CompactString>,
331 pub ports: Vec<ServerTunnelPort>,
332
333 pub created: chrono::DateTime<chrono::Utc>,
334}
335
336#[derive(ToSchema, Deserialize, Validate)]
337pub struct CreateServerTunnelPortOptions {
338 #[garde(range(min = 1))]
339 #[schema(minimum = 1)]
340 pub port: u16,
341 #[garde(custom(validate_protocols))]
342 pub protocols: HashSet<TunnelProtocol>,
343}
344
345pub struct ServerTunnelConnection;
346
347impl ServerTunnelConnection {
348 pub async fn by_src_server_uuid(
349 database: &crate::database::Database,
350 src_server_uuid: uuid::Uuid,
351 ) -> Result<Vec<uuid::Uuid>, crate::database::DatabaseError> {
352 Ok(sqlx::query_scalar(
353 r#"
354 SELECT server_tunnel_connections.dst_server_uuid
355 FROM server_tunnel_connections
356 WHERE server_tunnel_connections.src_server_uuid = $1
357 "#,
358 )
359 .bind(src_server_uuid)
360 .fetch_all(database.read())
361 .await?)
362 }
363
364 pub async fn peers(
365 database: &crate::database::Database,
366 server_uuid: uuid::Uuid,
367 incoming: bool,
368 configurations: &[super::egg_configuration::EggConfiguration],
369 ) -> Result<Vec<ServerTunnelPeer>, crate::database::DatabaseError> {
370 let (own, peer) = if incoming {
371 ("dst_server_uuid", "src_server_uuid")
372 } else {
373 ("src_server_uuid", "dst_server_uuid")
374 };
375
376 let rows = sqlx::query(sqlx::AssertSqlSafe(format!(
377 r#"
378 SELECT
379 server_tunnels.server_uuid,
380 server_tunnels.idx,
381 server_tunnels.name,
382 servers.name AS server_name,
383 servers.uuid_short,
384 server_tunnel_connections.created,
385 servers.egg_uuid,
386 nest_eggs.nest_uuid,
387 servers.node_uuid,
388 nodes.location_uuid
389 FROM server_tunnel_connections
390 JOIN server_tunnels ON server_tunnels.server_uuid = server_tunnel_connections.{peer}
391 JOIN servers ON servers.uuid = server_tunnels.server_uuid
392 JOIN nest_eggs ON nest_eggs.uuid = servers.egg_uuid
393 JOIN nodes ON nodes.uuid = servers.node_uuid
394 WHERE server_tunnel_connections.{own} = $1
395 ORDER BY server_tunnels.name
396 "#
397 )))
398 .bind(server_uuid)
399 .fetch_all(database.read())
400 .await?;
401
402 let peer_uuids = rows
403 .iter()
404 .map(|row| row.try_get("server_uuid"))
405 .collect::<Result<Vec<uuid::Uuid>, _>>()?;
406 let mut ports = ServerTunnelPort::by_server_uuids(database, &peer_uuids).await?;
407
408 let mut peers = Vec::with_capacity(rows.len());
409 for (row, server_uuid) in rows.into_iter().zip(peer_uuids) {
410 let target = super::egg_configuration::EggConfigurationTarget::map(&row)?;
411 if !super::egg_configuration::EggConfiguration::merge(configurations, &target)
412 .private_network_enabled()
413 {
414 continue;
415 }
416
417 peers.push(ServerTunnelPeer {
418 server_uuid,
419 server_name: row.try_get("server_name")?,
420 name: row.try_get("name")?,
421 alias: crate::tunnel::alias_of(row.try_get("uuid_short")?),
422 address: crate::tunnel::frontend_address(row.try_get::<i32, _>("idx")? as u16),
423 ports: ports.remove(&server_uuid).unwrap_or_default(),
424 created: row
425 .try_get::<chrono::NaiveDateTime, _>("created")?
426 .and_utc(),
427 });
428 }
429
430 Ok(peers)
431 }
432
433 pub async fn colliding_ports(
434 database: &crate::database::Database,
435 src_server_uuid: uuid::Uuid,
436 dst_server_uuid: uuid::Uuid,
437 ) -> Result<Vec<u16>, crate::database::DatabaseError> {
438 let ports: Vec<i32> = sqlx::query_scalar(
439 r#"
440 SELECT DISTINCT node_allocations.port
441 FROM server_allocations
442 JOIN node_allocations ON node_allocations.uuid = server_allocations.allocation_uuid
443 WHERE server_allocations.server_uuid = $1
444 AND node_allocations.port IN (
445 SELECT server_tunnel_ports.port
446 FROM server_tunnel_ports
447 WHERE server_tunnel_ports.server_uuid = $2
448 )
449 ORDER BY node_allocations.port
450 "#,
451 )
452 .bind(src_server_uuid)
453 .bind(dst_server_uuid)
454 .fetch_all(database.read())
455 .await?;
456
457 Ok(ports.into_iter().map(|port| port as u16).collect())
458 }
459
460 pub async fn count_by_src_server_uuid(
461 database: &crate::database::Database,
462 src_server_uuid: uuid::Uuid,
463 ) -> Result<i64, crate::database::DatabaseError> {
464 Ok(sqlx::query_scalar(
465 r#"
466 SELECT COUNT(*)
467 FROM server_tunnel_connections
468 WHERE server_tunnel_connections.src_server_uuid = $1
469 "#,
470 )
471 .bind(src_server_uuid)
472 .fetch_one(database.read())
473 .await?)
474 }
475
476 pub async fn create(
477 database: &crate::database::Database,
478 src_server_uuid: uuid::Uuid,
479 dst_server_uuid: uuid::Uuid,
480 ) -> Result<(), crate::database::DatabaseError> {
481 if src_server_uuid == dst_server_uuid {
482 return Err(crate::database::DatabaseError::Any(anyhow::anyhow!(
483 "a server cannot be connected to itself"
484 )));
485 }
486
487 let mut transaction = database.write().begin().await?;
488
489 let dst_name: compact_str::CompactString = sqlx::query_scalar(
490 r#"
491 SELECT server_tunnels.name
492 FROM server_tunnels
493 WHERE server_tunnels.server_uuid = $1
494 FOR KEY SHARE
495 "#,
496 )
497 .bind(dst_server_uuid)
498 .fetch_one(&mut *transaction)
499 .await?;
500
501 let affected = sqlx::query(
502 r#"
503 INSERT INTO server_tunnel_connections (src_server_uuid, dst_server_uuid, dst_name)
504 VALUES ($1, $2, $3)
505 ON CONFLICT (src_server_uuid, dst_server_uuid) DO NOTHING
506 "#,
507 )
508 .bind(src_server_uuid)
509 .bind(dst_server_uuid)
510 .bind(dst_name.as_str())
511 .execute(&mut *transaction)
512 .await?
513 .rows_affected();
514
515 if affected > 0 {
516 crate::tunnel::bump_epoch(&mut *transaction).await?;
517 }
518
519 transaction.commit().await?;
520
521 Ok(())
522 }
523
524 pub async fn delete(
525 database: &crate::database::Database,
526 src_server_uuid: uuid::Uuid,
527 dst_server_uuid: uuid::Uuid,
528 ) -> Result<bool, crate::database::DatabaseError> {
529 let mut transaction = database.write().begin().await?;
530
531 let affected = sqlx::query(
532 r#"
533 DELETE FROM server_tunnel_connections
534 WHERE server_tunnel_connections.src_server_uuid = $1
535 AND server_tunnel_connections.dst_server_uuid = $2
536 "#,
537 )
538 .bind(src_server_uuid)
539 .bind(dst_server_uuid)
540 .execute(&mut *transaction)
541 .await?
542 .rows_affected();
543
544 if affected == 0 {
545 return Ok(false);
546 }
547
548 crate::tunnel::bump_epoch(&mut *transaction).await?;
549 transaction.commit().await?;
550
551 Ok(true)
552 }
553}
554
555#[async_trait::async_trait]
556impl IntoApiObject for ServerTunnel {
557 type ApiObject = ApiServerTunnel;
558 type ExtraArgs<'a> = i32;
559
560 async fn into_api_object<'a>(
561 self,
562 state: &crate::State,
563 uuid_short: Self::ExtraArgs<'a>,
564 ) -> Result<Self::ApiObject, crate::database::DatabaseError> {
565 let api_object = ApiServerTunnel::init_hooks(&self, state).await?;
566
567 let api_object = finish_extendible!(
568 ApiServerTunnel {
569 name: self.name,
570 alias: crate::tunnel::alias_of(uuid_short),
571 address: crate::tunnel::frontend_address(self.idx),
572 created: self.created.and_utc(),
573 },
574 api_object,
575 state
576 )?;
577
578 Ok(api_object)
579 }
580}
581
582#[schema_extension_derive::extendible]
583#[init_args(ServerTunnel, crate::State)]
584#[hook_args(crate::State)]
585#[derive(ToSchema, Serialize)]
586#[schema(title = "ServerTunnel")]
587pub struct ApiServerTunnel {
588 pub name: compact_str::CompactString,
589 pub alias: compact_str::CompactString,
590 pub address: Option<compact_str::CompactString>,
591
592 pub created: chrono::DateTime<chrono::Utc>,
593}
594
595#[derive(ToSchema, Deserialize, Validate)]
596pub struct CreateServerTunnelOptions {
597 #[garde(skip)]
598 pub server_uuid: uuid::Uuid,
599
600 #[garde(custom(validate_name))]
601 #[schema(min_length = 1, max_length = 63)]
602 pub name: compact_str::CompactString,
603}
604
605#[async_trait::async_trait]
606impl CreatableModel for ServerTunnel {
607 type CreateOptions<'a> = CreateServerTunnelOptions;
608 type CreateResult = Self;
609
610 fn get_create_handlers() -> &'static LazyLock<CreateListenerList<Self>> {
611 static CREATE_LISTENERS: LazyLock<CreateListenerList<ServerTunnel>> =
612 LazyLock::new(|| Arc::new(ModelHandlerList::default()));
613
614 &CREATE_LISTENERS
615 }
616
617 async fn create_with_transaction(
618 state: &crate::State,
619 mut options: Self::CreateOptions<'_>,
620 transaction: &mut sqlx::Transaction<'_, sqlx::Postgres>,
621 ) -> Result<Self, crate::database::DatabaseError> {
622 options.validate()?;
623
624 let idx = Self::allocate_idx(transaction).await?;
625
626 let mut query_builder = InsertQueryBuilder::new("server_tunnels");
627
628 Self::run_create_handlers(&mut options, &mut query_builder, state, transaction).await?;
629
630 query_builder
631 .set("server_uuid", options.server_uuid)
632 .set("idx", idx)
633 .set("name", &options.name);
634
635 let row = query_builder
636 .returning(&Self::columns_sql(None))
637 .fetch_one(&mut **transaction)
638 .await?;
639 let mut server_tunnel = Self::map(None, &row)?;
640
641 crate::tunnel::bump_epoch(&mut **transaction).await?;
642
643 Self::run_after_create_handlers(&mut server_tunnel, &options, state, transaction).await?;
644
645 Ok(server_tunnel)
646 }
647}
648
649#[derive(ToSchema, Serialize, Deserialize, Validate, Default)]
650pub struct UpdateServerTunnelOptions {
651 #[garde(custom(validate_optional_name))]
652 #[schema(min_length = 1, max_length = 63)]
653 pub name: Option<compact_str::CompactString>,
654}
655
656#[async_trait::async_trait]
657impl UpdatableModel for ServerTunnel {
658 type UpdateOptions = UpdateServerTunnelOptions;
659
660 fn get_update_handlers() -> &'static LazyLock<UpdateHandlerList<Self>> {
661 static UPDATE_LISTENERS: LazyLock<UpdateHandlerList<ServerTunnel>> =
662 LazyLock::new(|| Arc::new(ModelHandlerList::default()));
663
664 &UPDATE_LISTENERS
665 }
666
667 async fn update_with_transaction(
668 &mut self,
669 state: &crate::State,
670 mut options: Self::UpdateOptions,
671 transaction: &mut sqlx::Transaction<'_, sqlx::Postgres>,
672 ) -> Result<(), crate::database::DatabaseError> {
673 options.validate()?;
674
675 let mut query_builder = UpdateQueryBuilder::new("server_tunnels");
676
677 self.run_update_handlers(&mut options, &mut query_builder, state, transaction)
678 .await?;
679
680 query_builder
681 .set("name", options.name.as_ref())
682 .where_eq("server_uuid", self.server.uuid);
683
684 query_builder.execute(&mut **transaction).await?;
685
686 crate::tunnel::bump_epoch(&mut **transaction).await?;
687
688 if let Some(name) = options.name {
689 self.name = name;
690 }
691
692 self.run_after_update_handlers(state, transaction).await?;
693
694 Ok(())
695 }
696}
697
698#[async_trait::async_trait]
699impl DeletableModel for ServerTunnel {
700 type DeleteOptions = ();
701
702 fn get_delete_handlers() -> &'static LazyLock<DeleteHandlerList<Self>> {
703 static DELETE_LISTENERS: LazyLock<DeleteHandlerList<ServerTunnel>> =
704 LazyLock::new(|| Arc::new(ModelHandlerList::default()));
705
706 &DELETE_LISTENERS
707 }
708
709 async fn delete_with_transaction(
710 &self,
711 state: &crate::State,
712 options: Self::DeleteOptions,
713 transaction: &mut sqlx::Transaction<'_, sqlx::Postgres>,
714 ) -> Result<(), anyhow::Error> {
715 self.run_delete_handlers(&options, state, transaction)
716 .await?;
717
718 sqlx::query(
719 r#"
720 DELETE FROM server_tunnels
721 WHERE server_tunnels.server_uuid = $1
722 "#,
723 )
724 .bind(self.server.uuid)
725 .execute(&mut **transaction)
726 .await?;
727
728 crate::tunnel::bump_epoch(&mut **transaction).await?;
729
730 self.run_after_delete_handlers(&options, state, transaction)
731 .await?;
732
733 Ok(())
734 }
735}