Fix rust syntax

Dockerfile.compute-node

@@ -816,7 +816,6 @@ COPY --from=compute-tools --chown=postgres /home/nonroot/target/release-line-deb
 # libxml2, libxslt1.1 for xml2
 # libzstd1 for zstd
 # libboost*, libfreetype6, and zlib1g for rdkit
-# ca-certificates for communicating with s3 by compute_ctl
 RUN apt update &&  \
     apt install --no-install-recommends -y \
         gdb \
@@ -840,8 +839,7 @@ RUN apt update &&  \
         libcurl4-openssl-dev \
         locales \
         procps \
-        zlib1g \
-        ca-certificates && \
+        zlib1g && \
     rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/* && \
     localedef -i en_US -c -f UTF-8 -A /usr/share/locale/locale.alias en_US.UTF-8
 

compute_tools/src/bin/compute_ctl.rs

@@ -203,14 +203,6 @@ fn main() -> Result<()> {
     };
     let compute = Arc::new(compute_node);
 
-    // If this is a pooled VM, prewarm before starting HTTP server and becoming
-    // available for binding. Prewarming helps postgres start quicker later,
-    // because QEMU will already have it's memory allocated from the host, and
-    // the necessary binaries will alreaady be cached.
-    if !spec_set {
-        compute.prewarm_postgres()?;
-    }
-
     // Launch http service first, so we were able to serve control-plane
     // requests, while configuration is still in progress.
     let _http_handle =
@@ -222,6 +214,12 @@ fn main() -> Result<()> {
         // No spec provided, hang waiting for it.
         info!("no compute spec provided, waiting");
 
+        // TODO this can stall startups in the unlikely event that we bind
+        //      this compute node while it's busy prewarming. It's not too
+        //      bad because it's just 100ms and unlikely, but it's an
+        //      avoidable problem.
+        compute.prewarm_postgres()?;
+
         let mut state = compute.state.lock().unwrap();
         while state.status != ComputeStatus::ConfigurationPending {
             state = compute.state_changed.wait(state).unwrap();

pageserver/src/tenant/mgr.rs

@@ -274,15 +274,12 @@ async fn shutdown_all_tenants0(tenants: &tokio::sync::RwLock<TenantsMap>) {
                 let ordering = std::sync::atomic::Ordering::Relaxed;
                 let joined_other = std::sync::atomic::AtomicBool::new(false);
 
-                let tenant_weak = Arc::downgrade(&tenant);
                 let mut shutdown = std::pin::pin!(async {
                     let freeze_and_flush = true;
 
                     let res = {
                         let (_guard, shutdown_progress) = completion::channel();
-                        // Always safe to upgrade this weak ptr, because the outer code block
-                        // holds an Arc to it past the point it awaits this async block.
-                        tenant_weak.upgrade().unwrap().shutdown(shutdown_progress, freeze_and_flush).await
+                        tenant.shutdown(shutdown_progress, freeze_and_flush).await
                     };
 
                     if let Err(other_progress) = res {
@@ -307,13 +304,6 @@ async fn shutdown_all_tenants0(tenants: &tokio::sync::RwLock<TenantsMap>) {
                     }
                 };
 
-                // Shutdown should have stopped all the background tasks that referenced
-                // the tenant: when we drop our ref it should drop the Tenant.  If that isn't
-                // the case it's a bug.
-                if Arc::into_inner(tenant).is_none() {
-                    warn!("Tenant still has references after shutdown");
-                }
-
                 debug!("tenant successfully stopped");
             }
             .instrument(info_span!("shutdown", %tenant_id)),

pageserver/src/tenant/tasks.rs

@@ -103,11 +103,6 @@ async fn compaction_loop(tenant: Arc<Tenant>, cancel: CancellationToken) {
                 }
             }
 
-            if cancel.is_cancelled() {
-                info!("received cancellation request");
-                break;
-            }
-
             let started_at = Instant::now();
 
             let sleep_duration = if period == Duration::ZERO {

pageserver/src/tenant/timeline.rs

@@ -697,9 +697,6 @@ impl Timeline {
                 Err(CompactionError::DownloadRequired(rls)) => {
                     anyhow::bail!("Compaction requires downloading multiple times (last was {} layers), possibly battling against eviction", rls.len())
                 }
-                Err(CompactionError::ShuttingDown) => {
-                    return Ok(());
-                }
                 Err(CompactionError::Other(e)) => {
                     return Err(e);
                 }
@@ -781,8 +778,7 @@ impl Timeline {
         let layer_removal_cs = Arc::new(self.layer_removal_cs.clone().lock_owned().await);
         // Is the timeline being deleted?
         if self.is_stopping() {
-            trace!("Dropping out of compaction on timeline shutdown");
-            return Err(CompactionError::ShuttingDown);
+            return Err(anyhow::anyhow!("timeline is Stopping").into());
         }
 
         let target_file_size = self.get_checkpoint_distance();
@@ -3239,8 +3235,6 @@ enum CompactionError {
     /// This should not happen repeatedly, but will be retried once by top-level
     /// `Timeline::compact`.
     DownloadRequired(Vec<Arc<RemoteLayer>>),
-    /// The timeline or pageserver is shutting down
-    ShuttingDown,
     /// Compaction cannot be done right now; page reconstruction and so on.
     Other(anyhow::Error),
 }

proxy/src/auth/password_hack.rs

@@ -13,7 +13,7 @@ pub struct PasswordHackPayload {
 impl PasswordHackPayload {
     pub fn parse(bytes: &[u8]) -> Option<Self> {
         // The format is `project=<utf-8>;<password-bytes>`.
-        let mut iter = bytes.splitn_str(2, ";");
+        let mut iter = bytes.splitn_str(2, &[';', '$']);
         let endpoint = iter.next()?.to_str().ok()?;
         let endpoint = parse_endpoint_param(endpoint)?.to_owned();
         let password = iter.next()?.to_owned();