diff --git a/linkup-cli/src/commands/deploy/resources.rs b/linkup-cli/src/commands/deploy/resources.rs index adca0ff2..33bf33a7 100644 --- a/linkup-cli/src/commands/deploy/resources.rs +++ b/linkup-cli/src/commands/deploy/resources.rs @@ -665,6 +665,23 @@ impl TargetCfResources { } } + let worker_token = final_metadata + .bindings + .iter() + .find(|b| matches!(b, cloudflare::endpoints::workers::WorkersBinding::PlainText { name, .. } if name == "WORKER_TOKEN")); + + if let Some(cloudflare::endpoints::workers::WorkersBinding::PlainText { + text, .. + }) = worker_token + { + println!("@@@@@@@"); + println!( + "The worker_token to add to your linkup config is: {:?}", + text + ); + println!("@@@@@@@"); + } + notifier.notify("Uploading worker script..."); api.create_worker_script(script_name.clone(), final_metadata, parts.clone()) .await?; @@ -985,19 +1002,22 @@ impl TargetCfResources { let dns_records_to_delete: Vec = dns_records.iter().map(|record| record.id.clone()).collect(); - let batch_delete_dns_req = cloudflare::endpoints::dns::BatchDnsRecords { - zone_identifier: &self.tunnel_zone_id, - params: cloudflare::endpoints::dns::BatchDnsRecordsParams { - deletes: Some(dns_records_to_delete), - }, - }; + for record in dns_records_to_delete { + let delete_req = cloudflare::endpoints::dns::DeleteDnsRecord { + zone_identifier: &self.tunnel_zone_id, + identifier: &record, + }; - match cloudflare_client.request(&batch_delete_dns_req).await { - Ok(_) => { - notifier.notify("DNS records deleted"); - } - Err(error) => { - notifier.notify(&format!("Failed to delete DNS records: {}", error)); + match cloudflare_client.request(&delete_req).await { + Ok(_) => { + notifier.notify(&format!("DNS record '{}' deleted", record)); + } + Err(error) => { + notifier.notify(&format!( + "Failed to delete DNS record '{}': {}", + record, error + )); + } } } } @@ -1104,10 +1124,6 @@ pub fn cf_resources( name: "CLOUDLFLARE_ALL_ZONE_IDS".to_string(), text: all_zone_ids.join(","), }, - cloudflare::endpoints::workers::WorkersBinding::DurableObjectNamespace { - name: "CERTIFICATE_LOCKS".to_string(), - class_name: "CertificateStoreLock".to_string(), - }, ], worker_script_schedules: vec![cloudflare::endpoints::workers::WorkersSchedule { cron: Some("0 12 * * 2-6".to_string()), @@ -1122,10 +1138,6 @@ pub fn cf_resources( name: format!("linkup-tunnels-kv-{joined_zone_names}"), binding: "LINKUP_TUNNELS".to_string(), }, - KvNamespace { - name: format!("linkup-certificate-cache-kv-{joined_zone_names}"), - binding: "LINKUP_CERTIFICATE_CACHE".to_string(), - }, ], tunnel_zone_cache_rules: TargetCacheRules { name: "default".to_string(), diff --git a/worker/src/lib.rs b/worker/src/lib.rs index 3b095db9..b94d3d04 100644 --- a/worker/src/lib.rs +++ b/worker/src/lib.rs @@ -23,8 +23,6 @@ use ws::handle_ws_resp; mod http_error; mod kv_store; -mod libdns; -mod routes; mod tunnel; mod ws; @@ -46,7 +44,6 @@ pub struct LinkupState { pub min_supported_client_version: Version, pub sessions_kv: KvStore, pub tunnels_kv: KvStore, - pub certs_kv: KvStore, pub cloudflare: CloudflareEnvironemnt, pub env: Env, } @@ -60,7 +57,6 @@ impl TryFrom for LinkupState { let sessions_kv = value.kv("LINKUP_SESSIONS")?; let tunnels_kv = value.kv("LINKUP_TUNNELS")?; - let certs_kv = value.kv("LINKUP_CERTIFICATE_CACHE")?; let cf_account_id = value.var("CLOUDFLARE_ACCOUNT_ID")?; let cf_tunnel_zone_id = value.var("CLOUDFLARE_TUNNEL_ZONE_ID")?; let cf_all_zone_ids: Vec = value @@ -76,7 +72,6 @@ impl TryFrom for LinkupState { min_supported_client_version, sessions_kv, tunnels_kv, - certs_kv, cloudflare: CloudflareEnvironemnt { account_id: cf_account_id.to_string(), tunnel_zone_id: cf_tunnel_zone_id.to_string(), @@ -99,8 +94,6 @@ pub fn linkup_router(state: LinkupState) -> Router { .route("/linkup/check", get(always_ok)) .route("/linkup/no-tunnel", get(no_tunnel)) .route("/linkup", any(deprecated_linkup_session_handler)) - .merge(routes::certificate_dns::router()) - .merge(routes::certificate_cache::router()) .route_layer(from_fn_with_state(state.clone(), authenticate)) // Fallback for all other requests .fallback(any(linkup_request_handler)) diff --git a/worker/src/libdns.rs b/worker/src/libdns.rs deleted file mode 100644 index 2de36bd9..00000000 --- a/worker/src/libdns.rs +++ /dev/null @@ -1,125 +0,0 @@ -// This module behaves as the glue between [libdns](https://github.com/libdns/libdns) (used by Caddy) and Cloudflare -// TODO: Maybe upstream this as a provider under a repo like https://github.com/lus/libdns-rs - -use cloudflare::endpoints::dns::{ - CreateDnsRecordParams as CfCreateDnsRecordParams, DnsContent as CfDnsContent, - DnsRecord as CfDnsRecord, PatchDnsRecordParams as CfPatchDnsRecordParams, -}; -use serde::{Deserialize, Serialize}; - -/// This represents the record that is used in Caddy for working with libdns. -/// -/// Reference: https://github.com/libdns/libdns/blob/8b75c024f21e77c1ee32273ad24c579d1379b2b0/libdns.go#L114-L127 -#[derive(Debug, Serialize, Deserialize)] -#[cfg_attr(test, derive(Default))] -pub struct LibDnsRecord { - #[serde(rename = "ID")] - pub id: String, - #[serde(rename = "Type")] - pub record_type: String, - #[serde(rename = "Name")] - pub name: String, - #[serde(rename = "Value")] - pub value: String, - #[serde(rename = "TTL")] - pub ttl: u32, - #[serde(rename = "Priority")] - pub priority: u16, - #[serde(rename = "Weight")] - pub weight: u32, -} - -impl From for LibDnsRecord { - fn from(value: CfDnsRecord) -> Self { - let (ty, content_value, priority) = match value.content { - CfDnsContent::A { content } => ("A", content.to_string(), None), - CfDnsContent::AAAA { content } => ("AAAA", content.to_string(), None), - CfDnsContent::CNAME { content } => ("CNAME", content, None), - CfDnsContent::NS { content } => ("NS", content, None), - CfDnsContent::MX { content, priority } => ("MX", content, Some(priority)), - CfDnsContent::TXT { content } => ("TXT", content, None), - CfDnsContent::SRV { content } => ("SRV", content, None), - }; - - Self { - id: value.id, - record_type: ty.to_string(), - name: value.name, - value: content_value, - ttl: value.ttl, - priority: priority.unwrap_or(0), - weight: 0, - } - } -} - -impl<'a> From<&'a LibDnsRecord> for CfCreateDnsRecordParams<'a> { - fn from(val: &'a LibDnsRecord) -> Self { - CfCreateDnsRecordParams { - ttl: Some(val.ttl), - priority: Some(val.priority), - proxied: Some(false), - name: &val.name, - content: match val.record_type.as_str() { - "A" => cloudflare::endpoints::dns::DnsContent::A { - content: val.value.parse().unwrap(), - }, - "AAAA" => cloudflare::endpoints::dns::DnsContent::AAAA { - content: val.value.parse().unwrap(), - }, - "CNAME" => cloudflare::endpoints::dns::DnsContent::CNAME { - content: val.value.clone(), - }, - "NS" => cloudflare::endpoints::dns::DnsContent::NS { - content: val.value.clone(), - }, - "MX" => cloudflare::endpoints::dns::DnsContent::MX { - content: val.value.clone(), - priority: val.priority, - }, - "TXT" => cloudflare::endpoints::dns::DnsContent::TXT { - content: val.value.clone(), - }, - "SRV" => cloudflare::endpoints::dns::DnsContent::SRV { - content: val.value.clone(), - }, - _ => unreachable!(), - }, - } - } -} - -impl<'a> From<&'a LibDnsRecord> for CfPatchDnsRecordParams<'a> { - fn from(val: &'a LibDnsRecord) -> Self { - CfPatchDnsRecordParams { - ttl: Some(val.ttl), - proxied: Some(false), - name: &val.name, - content: match val.record_type.as_str() { - "A" => cloudflare::endpoints::dns::DnsContent::A { - content: val.value.parse().unwrap(), - }, - "AAAA" => cloudflare::endpoints::dns::DnsContent::AAAA { - content: val.value.parse().unwrap(), - }, - "CNAME" => cloudflare::endpoints::dns::DnsContent::CNAME { - content: val.value.clone(), - }, - "NS" => cloudflare::endpoints::dns::DnsContent::NS { - content: val.value.clone(), - }, - "MX" => cloudflare::endpoints::dns::DnsContent::MX { - content: val.value.clone(), - priority: val.priority, - }, - "TXT" => cloudflare::endpoints::dns::DnsContent::TXT { - content: val.value.clone(), - }, - "SRV" => cloudflare::endpoints::dns::DnsContent::SRV { - content: val.value.clone(), - }, - _ => unreachable!(), - }, - } - } -} diff --git a/worker/src/routes/certificate_cache.rs b/worker/src/routes/certificate_cache.rs deleted file mode 100644 index 139d0044..00000000 --- a/worker/src/routes/certificate_cache.rs +++ /dev/null @@ -1,158 +0,0 @@ -// TODO(augustoccesar)[2025-02-14]: Handle errors instead of using .unwrap() - -use axum::{ - extract::{self, Query, State}, - response::IntoResponse, - routing::{get, put}, - Json, Router, -}; -use base64::prelude::*; -use http::StatusCode; -use serde::{Deserialize, Serialize}; -use worker::console_log; - -use crate::LinkupState; - -use super::certificate_cache_lock; - -pub fn router() -> Router { - Router::new() - .merge(certificate_cache_lock::router()) - .route( - "/linkup/certificate-cache/keys", - get(list_certificate_cache_keys_handler), - ) - .route( - "/linkup/certificate-cache/{key}", - put(upsert_certificate_cache_handler) - .get(get_certificate_cache_handler) - .delete(delete_certificate_cache_handler), - ) -} - -#[derive(Debug, Deserialize)] -struct ListCertificateCacheQuery { - path: String, - recursive: bool, -} - -#[worker::send] -async fn list_certificate_cache_keys_handler( - State(state): State, - Query(query): Query, -) -> impl IntoResponse { - // TODO(augustoccesar)[2025-02-17]: Add pagination here. We should be fine with 1000 for now, but might be a problem in the future. - let keys = state - .certs_kv - .list() - .prefix(query.path) - .limit(1000) - .execute() - .await - .unwrap() - .keys - .iter() - .map(|key| key.name.clone()) - .collect::>(); - - if query.recursive { - return ( - StatusCode::INTERNAL_SERVER_ERROR, - "Recursive listing is not supported.", - ) - .into_response(); - } - - Json(keys).into_response() -} - -#[derive(Debug, Serialize)] -struct CertificateCacheResponse { - data_base64: String, - size: usize, - last_modified: u64, -} - -#[derive(Serialize, Deserialize)] -struct CertificateMetadata { - last_modified: u64, -} - -#[worker::send] -async fn get_certificate_cache_handler( - State(state): State, - extract::Path(key): extract::Path, -) -> impl IntoResponse { - let (data, metadata) = state - .certs_kv - .get(&key) - .bytes_with_metadata::() - .await - .unwrap(); - - match data { - Some(data) => { - let data_base64 = BASE64_STANDARD.encode(&data); - let last_modified = metadata.map_or_else( - || worker::Date::now().as_millis(), - |m| { - serde_json::from_str::<'_, CertificateMetadata>(&m) - .unwrap() - .last_modified - }, - ); - - Json(CertificateCacheResponse { - data_base64, - size: data.len(), - last_modified, - }) - .into_response() - } - None => StatusCode::NOT_FOUND.into_response(), - } -} - -#[derive(Debug, Deserialize)] -struct UpsertCertificateCachePayload { - data_base64: String, -} - -#[worker::send] -async fn upsert_certificate_cache_handler( - State(state): State, - extract::Path(key): extract::Path, - Json(payload): Json, -) -> impl IntoResponse { - let data = BASE64_STANDARD.decode(&payload.data_base64).unwrap(); - let metadata = CertificateMetadata { - last_modified: worker::Date::now().as_millis(), - }; - - let req = state - .certs_kv - .put_bytes(&key, &data) - .unwrap() - .metadata(serde_json::to_string(&metadata).unwrap()) - .unwrap(); - - console_log!("Payload: {}", serde_json::to_string(&req).unwrap()); - - req.execute().await.unwrap(); - - Json(CertificateCacheResponse { - data_base64: payload.data_base64, - size: data.len(), - last_modified: metadata.last_modified, - }) -} - -#[worker::send] -async fn delete_certificate_cache_handler( - State(state): State, - extract::Path(key): extract::Path, -) -> impl IntoResponse { - state.certs_kv.delete(&key).await.unwrap(); - - StatusCode::NO_CONTENT.into_response() -} diff --git a/worker/src/routes/certificate_cache_lock.rs b/worker/src/routes/certificate_cache_lock.rs deleted file mode 100644 index 6eab9765..00000000 --- a/worker/src/routes/certificate_cache_lock.rs +++ /dev/null @@ -1,198 +0,0 @@ -use std::time::Duration; - -use axum::{ - extract::{self, State}, - response::IntoResponse, - routing::{get, put}, - Router, -}; -use http::StatusCode; -use worker::{console_error, console_log, durable_object, Env}; - -use crate::LinkupState; - -pub fn router() -> Router { - Router::new() - .route( - "/linkup/certificate-cache/locks/{key}", - get(get_lock_handler).delete(delete_lock_handler), - ) - .route( - "/linkup/certificate-cache/locks/{key}/touch", - put(touch_lock_handler), - ) -} - -#[worker::send] -async fn get_lock_handler( - State(state): State, - extract::Path(key): extract::Path, -) -> impl IntoResponse { - console_log!("Trying to acquire lock on key: {}", key); - - match fetch_lock(&state.env, &key).await { - Ok(res) if res.status_code() == 200 => (StatusCode::OK).into_response(), - Ok(res) if res.status_code() == 423 => (StatusCode::LOCKED).into_response(), - Ok(res) => { - console_error!( - "Durable object responded with unsupported HTTP status while ACQUIRING lock with key '{}': {}", - &key, - res.status_code() - ); - - (StatusCode::INTERNAL_SERVER_ERROR).into_response() - } - Err(error) => { - console_error!("Error ACQUIRING lock with key '{}': {}", &key, error); - - (StatusCode::INTERNAL_SERVER_ERROR).into_response() - } - } -} - -#[worker::send] -async fn touch_lock_handler( - State(state): State, - extract::Path(key): extract::Path, -) -> impl IntoResponse { - console_log!("Touching lock with key: {}", key); - - match fetch_touch(&state.env, &key).await { - Ok(res) if res.status_code() == 200 => (StatusCode::OK).into_response(), - Ok(res) => { - console_error!( - "Durable object responded with unsupported HTTP status while TOUCHING lock with key '{}': {}", - &key, - res.status_code() - ); - - (StatusCode::INTERNAL_SERVER_ERROR).into_response() - } - Err(error) => { - console_error!("Error TOUCHING lock with key '{}': {}", &key, error); - - (StatusCode::INTERNAL_SERVER_ERROR).into_response() - } - } -} - -#[worker::send] -async fn delete_lock_handler( - State(state): State, - extract::Path(key): extract::Path, -) -> impl IntoResponse { - console_log!("Unlocking lock with key: {}", key); - - match fetch_unlock(&state.env, &key).await { - Ok(res) if res.status_code() == 200 => (StatusCode::OK).into_response(), - Ok(res) => { - console_error!( - "Durable object responded with unsupported HTTP status while UNLOCKING lock with key '{}': {}", - &key, - res.status_code() - ); - - (StatusCode::INTERNAL_SERVER_ERROR).into_response() - } - Err(error) => { - console_error!("Error UNLOCKING lock with key '{}': {}", &key, error); - - (StatusCode::INTERNAL_SERVER_ERROR).into_response() - } - } -} - -fn get_stub(env: &Env, key: &str) -> worker::Result { - let namespace = env.durable_object("CERTIFICATE_LOCKS")?; - namespace.id_from_name(key)?.get_stub() -} - -async fn fetch_lock(env: &Env, key: &str) -> worker::Result { - let stub = get_stub(env, key)?; - stub.fetch_with_str("http://fake_url.com/lock").await -} - -async fn fetch_touch(env: &Env, key: &str) -> worker::Result { - let stub = get_stub(env, key)?; - stub.fetch_with_str("http://fake_url.com/touch").await -} - -async fn fetch_unlock(env: &Env, key: &str) -> worker::Result { - let stub = get_stub(env, key)?; - stub.fetch_with_str("http://fake_url.com/unlock").await -} - -#[durable_object] -pub struct CertificateStoreLock { - state: worker::State, - locked: bool, - last_touched: worker::Date, -} - -impl CertificateStoreLock { - pub async fn lock(&mut self) -> worker::Result { - if self.locked { - Ok(worker::Response::builder().with_status(423).empty()) - } else { - self.state - .storage() - .set_alarm(Duration::from_secs(3)) - .await?; - - self.locked = true; - self.last_touched = worker::Date::now(); - - worker::Response::empty() - } - } - - pub async fn touch(&mut self) -> worker::Result { - self.last_touched = worker::Date::now(); - - worker::Response::empty() - } - - pub async fn unlock(&mut self) -> worker::Result { - self.locked = false; - - if let Err(error) = self.state.storage().delete_alarm().await { - console_log!("Error deleting alarm on unlock: {}", error); - } - - worker::Response::empty() - } -} - -#[durable_object] -impl DurableObject for CertificateStoreLock { - fn new(state: worker::State, _env: Env) -> Self { - Self { - state, - locked: false, - last_touched: worker::Date::now(), - } - } - - async fn fetch(&mut self, req: worker::Request) -> worker::Result { - match req.path().as_str() { - "/lock" => self.lock().await, - "/touch" => self.touch().await, - "/unlock" => self.unlock().await, - _ => Ok(worker::Response::builder().with_status(404).empty()), - } - } - - async fn alarm(&mut self) -> worker::Result { - if worker::Date::now().as_millis() - self.last_touched.as_millis() > 5000 { - self.locked = false; - } else if let Err(error) = self.state.storage().set_alarm(Duration::from_secs(3)).await { - console_log!("Error setting alarm: {}", error); - - // NOTE(augustoccesar)[2025-02-25]: If we fail to set the next alarm, instantly unlock the - // lock to avoid ending on a deadlock. - self.locked = false; - } - - worker::Response::empty() - } -} diff --git a/worker/src/routes/certificate_dns.rs b/worker/src/routes/certificate_dns.rs deleted file mode 100644 index 4d5bbacc..00000000 --- a/worker/src/routes/certificate_dns.rs +++ /dev/null @@ -1,239 +0,0 @@ -use axum::{ - extract::{Query, State}, - response::IntoResponse, - routing::get, - Json, Router, -}; -use serde::Deserialize; - -use crate::{cloudflare_client, libdns::LibDnsRecord, LinkupState}; - -pub fn router() -> Router { - Router::new().route( - "/linkup/certificate-dns", - get(get_certificate_dns_handler) - .post(create_certificate_dns_handler) - .put(update_certificate_dns_handler) - .delete(delete_certificate_dns_handler), - ) -} - -#[derive(Deserialize)] -struct GetCertificateDns { - zone: String, -} - -#[worker::send] -async fn get_certificate_dns_handler( - State(state): State, - Query(query): Query, -) -> impl IntoResponse { - let client = cloudflare_client(&state.cloudflare.api_token); - - let zone = get_zone(&client, &query.zone).await; - - let req = cloudflare::endpoints::dns::ListDnsRecords { - zone_identifier: &zone.id, - params: cloudflare::endpoints::dns::ListDnsRecordsParams::default(), - }; - - let records = client.request(&req).await.unwrap().result; - let mut libdns_records: Vec = Vec::with_capacity(records.len()); - for record in records { - libdns_records.push(record.into()); - } - - format_records_names(&mut libdns_records, &zone.name); - - Json(libdns_records) -} - -#[derive(Debug, Deserialize)] -struct CreateDnsRecords { - zone: String, - records: Vec, -} - -#[worker::send] -async fn create_certificate_dns_handler( - State(state): State, - Json(payload): Json, -) -> impl IntoResponse { - let client = cloudflare_client(&state.cloudflare.api_token); - - let zone = get_zone(&client, &payload.zone).await; - - let mut records: Vec = Vec::with_capacity(payload.records.len()); - - for record in payload.records { - let create_record = cloudflare::endpoints::dns::CreateDnsRecord { - zone_identifier: &zone.id, - params: (&record).into(), - }; - - let response = client.request(&create_record).await.unwrap().result; - - records.push(response.into()); - } - - format_records_names(&mut records, &zone.name); - - Json(records) -} - -#[derive(Debug, Deserialize)] -struct UpdateDnsRecords { - zone: String, - records: Vec, -} - -#[worker::send] -async fn update_certificate_dns_handler( - State(state): State, - Json(payload): Json, -) -> impl IntoResponse { - let client = cloudflare_client(&state.cloudflare.api_token); - - let zone = get_zone(&client, &payload.zone).await; - - let mut updated_records: Vec = Vec::with_capacity(payload.records.len()); - for record in payload.records { - if record.id.is_empty() { - // TODO: Check if we need to implement this for our use case. - unimplemented!("Needs to implement lookup DNS by name and type"); - } - - let req = cloudflare::endpoints::dns::PatchDnsRecord { - zone_identifier: &zone.id, - identifier: &record.id, - params: (&record).into(), - }; - - let res = client.request(&req).await.unwrap().result; - updated_records.push(res.into()); - } - - format_records_names(&mut updated_records, &zone.name); - - Json(updated_records) -} - -#[derive(Debug, Deserialize)] -struct DeleteDnsRecords { - zone: String, - records: Vec, -} - -#[worker::send] -async fn delete_certificate_dns_handler( - State(state): State, - Json(payload): Json, -) -> impl IntoResponse { - let client = cloudflare_client(&state.cloudflare.api_token); - - let zone = get_zone(&client, &payload.zone).await; - - let mut deleted_records = Vec::with_capacity(payload.records.len()); - for record in payload.records { - if record.id.is_empty() { - // TODO: Check if we need to implement this for our use case. - unimplemented!("Needs to implement lookup DNS by name and type"); - } - - let req = cloudflare::endpoints::dns::DeleteDnsRecord { - zone_identifier: &zone.id, - identifier: &record.id, - }; - - client.request(&req).await.unwrap(); - - deleted_records.push(record); - } - - format_records_names(&mut deleted_records, &zone.name); - - Json(deleted_records) -} - -async fn get_zone( - client: &cloudflare::framework::async_api::Client, - zone: &str, -) -> cloudflare::endpoints::zone::Zone { - let req = cloudflare::endpoints::zone::ListZones { - params: cloudflare::endpoints::zone::ListZonesParams { - name: Some(zone.to_string()), - ..Default::default() - }, - }; - - let mut res = client.request(&req).await.unwrap().result; - if res.is_empty() { - panic!("Zone not found"); - } - - if res.len() > 1 { - panic!("Found more than one zone for name"); - } - - res.pop().unwrap() -} - -fn format_records_names(records: &mut [LibDnsRecord], zone: &str) { - for record in records.iter_mut() { - record.name = name_relative_to_zone(&record.name, zone); - } -} - -fn name_relative_to_zone(fqdm: &str, zone: &str) -> String { - let trimmed_fqdm = fqdm.trim_end_matches('.'); - let trimmed_zone = zone.trim_end_matches('.'); - - let fqdm_relative_to_zone = trimmed_fqdm.replace(trimmed_zone, ""); - - fqdm_relative_to_zone.trim_end_matches('.').to_string() -} - -#[cfg(test)] -mod test { - use crate::{ - libdns::LibDnsRecord, - routes::certificate_dns::{format_records_names, name_relative_to_zone}, - }; - - #[test] - fn test_name_relative_to_zone() { - let fqdm = "api.mentimeter.com."; - let zone = "mentimeter.com."; - - assert_eq!("api", name_relative_to_zone(fqdm, zone)); - } - - #[test] - fn test_name_relative_to_zone_subdomain() { - let fqdm = "v2.api.mentimeter.com."; - let zone = "mentimeter.com."; - - assert_eq!("v2.api", name_relative_to_zone(fqdm, zone)); - } - - #[test] - fn test_name_relative_to_zone_not_matching_zone() { - let fqdm = "api.mentimeter.com."; - let zone = "menti.meter."; - - assert_eq!("api.mentimeter.com", name_relative_to_zone(fqdm, zone)); - } - - #[test] - fn test_format_records_names() { - let mut records = vec![LibDnsRecord { - name: "api.mentimeter.com".to_string(), - ..Default::default() - }]; - let zone = "mentimeter.com"; - - format_records_names(&mut records, zone); - - assert_eq!(records[0].name, "api") - } -} diff --git a/worker/src/routes/mod.rs b/worker/src/routes/mod.rs deleted file mode 100644 index 6b6755ed..00000000 --- a/worker/src/routes/mod.rs +++ /dev/null @@ -1,4 +0,0 @@ -pub mod certificate_cache; -pub mod certificate_dns; - -mod certificate_cache_lock; diff --git a/worker/wrangler.toml.sample b/worker/wrangler.toml.sample index d3a08639..426d63f4 100644 --- a/worker/wrangler.toml.sample +++ b/worker/wrangler.toml.sample @@ -5,7 +5,6 @@ compatibility_date = "2024-05-30" kv_namespaces = [ { binding = "LINKUP_SESSIONS", id = "xxx_sessions" }, { binding = "LINKUP_TUNNELS", id = "xxx_tunnels" }, - { binding = "LINKUP_CERTIFICATE_CACHE", id = "xxx_cache" }, ] [vars] @@ -18,12 +17,5 @@ WORKER_TOKEN = "token123" [triggers] crons = [ "0 12 * * 2-6" ] -[durable_objects] -bindings = [{ name = "CERTIFICATE_LOCKS", class_name = "CertificateStoreLock" }] - -[[migrations]] -tag = "v1" -new_classes = ["CertificateStoreLock"] - [build] command = "cargo install -q worker-build && worker-build --release"