Skip to main content

shared/models/
server_tunnel.rs

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}