fix: Open the endpoints after the config is loaded

We get the injected TokioComponent dependency before the config is
loaded, so we can't use it to open the endpoints.

And we can't define after_config, because we use derive(Component).

So we work around these issues by opening the endpoints manually,
from the application's after_config.

zebrad/src/application.rs

@@ -126,6 +126,10 @@ impl Application for ZebradApp {
         config: Self::Cfg,
         command: &Self::Cmd,
     ) -> Result<(), FrameworkError> {
+        use crate::components::{
+            metrics::MetricsEndpoint, tokio::TokioComponent, tracing::TracingEndpoint,
+        };
+
         // Configure components
         self.state.components.after_config(&config)?;
         self.config = Some(config);
@@ -137,6 +141,30 @@ impl Application for ZebradApp {
                 .get_downcast_mut::<Tracing>()
                 .expect("Tracing component should be available")
                 .reload_filter(level);
+
+            // Work around some issues with dependency injection and configs
+            let config = self
+                .config
+                .clone()
+                .expect("config was set to Some earlier in this function");
+
+            let tokio_component = self
+                .state
+                .components
+                .get_downcast_ref::<TokioComponent>()
+                .expect("Tokio component should be available");
+
+            self.state
+                .components
+                .get_downcast_ref::<TracingEndpoint>()
+                .expect("Tracing endpoint should be available")
+                .open_endpoint(&config.tracing, tokio_component);
+
+            self.state
+                .components
+                .get_downcast_ref::<MetricsEndpoint>()
+                .expect("Metrics endpoint should be available")
+                .open_endpoint(&config.metrics, tokio_component);
         }
 
         Ok(())

zebrad/src/components/metrics.rs

@@ -1,6 +1,6 @@
 //! An HTTP endpoint for metrics collection.
 
-use crate::{components::tokio::TokioComponent, prelude::*};
+use crate::{components::tokio::TokioComponent, config::MetricsSection};
 
 use abscissa_core::{Component, FrameworkError};
 
@@ -17,11 +17,22 @@ impl MetricsEndpoint {
         Ok(Self {})
     }
 
-    /// Do setup after receiving a tokio runtime.
-    pub fn init_tokio(&mut self, tokio_component: &TokioComponent) -> Result<(), FrameworkError> {
+    /// Tokio endpoint dependency stub.
+    ///
+    /// We can't open the endpoint here, because the config has not been loaded.
+    pub fn init_tokio(&mut self, _tokio_component: &TokioComponent) -> Result<(), FrameworkError> {
+        Ok(())
+    }
+
+    /// Open the metrics endpoint.
+    ///
+    /// We can't implement `after_config`, because we use `derive(Component)`.
+    /// And the ownership rules might make it hard to access the TokioComponent
+    /// from `after_config`.
+    pub fn open_endpoint(&self, metrics_config: &MetricsSection, tokio_component: &TokioComponent) {
         info!("Initializing metrics endpoint");
 
-        let addr = app_config().metrics.endpoint_addr;
+        let addr = metrics_config.endpoint_addr;
 
         // XXX do we need to hold on to the receiver?
         let receiver = Receiver::builder()
@@ -39,7 +50,5 @@ impl MetricsEndpoint {
             .spawn(endpoint.async_run());
 
         metrics::set_boxed_recorder(Box::new(receiver)).expect("XXX FIXME ERROR CONVERSION");
-
-        Ok(())
     }
 }

zebrad/src/components/tracing.rs

@@ -1,6 +1,6 @@
 //! An HTTP endpoint for dynamically setting tracing filters.
 
-use crate::{components::tokio::TokioComponent, prelude::*};
+use crate::{components::tokio::TokioComponent, config::TracingSection, prelude::*};
 
 use abscissa_core::{Component, FrameworkError};
 
@@ -28,14 +28,25 @@ impl TracingEndpoint {
         Ok(Self {})
     }
 
-    /// Do setup after receiving a tokio runtime.
-    pub fn init_tokio(&mut self, tokio_component: &TokioComponent) -> Result<(), FrameworkError> {
+    /// Tokio endpoint dependency stub.
+    ///
+    /// We can't open the endpoint here, because the config has not been loaded.
+    pub fn init_tokio(&mut self, _tokio_component: &TokioComponent) -> Result<(), FrameworkError> {
+        Ok(())
+    }
+
+    /// Open the tracing endpoint.
+    ///
+    /// We can't implement `after_config`, because we use `derive(Component)`.
+    /// And the ownership rules might make it hard to access the TokioComponent
+    /// from `after_config`.
+    pub fn open_endpoint(&self, tracing_config: &TracingSection, tokio_component: &TokioComponent) {
         info!("Initializing tracing endpoint");
 
         let service =
             make_service_fn(|_| async { Ok::<_, hyper::Error>(service_fn(request_handler)) });
 
-        let addr = app_config().tracing.endpoint_addr;
+        let addr = tracing_config.endpoint_addr;
 
         tokio_component
             .rt
@@ -58,8 +69,6 @@ impl TracingEndpoint {
                     error!("Server error: {}", e);
                 }
             });
-
-        Ok(())
     }
 }