debug: log more

Author: lutter

store/postgres/src/connection_pool.rs

@@ -1,10 +1,11 @@
 use diesel::r2d2::Builder;
+use diesel::sql_types::Text;
 use diesel::{connection::SimpleConnection, pg::PgConnection};
 use diesel::{
     r2d2::{self, event as e, ConnectionManager, HandleEvent, Pool, PooledConnection},
     Connection,
 };
-use diesel::{sql_query, RunQueryDsl};
+use diesel::{sql_query, OptionalExtension, RunQueryDsl};
 
 use diesel_migrations::{EmbeddedMigrations, HarnessWithOutput};
 use graph::cheap_clone::CheapClone;
@@ -380,13 +381,18 @@ impl PoolState {
 
             use PoolStateInner::*;
             match &*guard {
-                Created(pool, coord) => (pool.cheap_clone(), coord.cheap_clone()),
+                Created(pool, coord) => {
+                    warn!(self.logger, "pool_state: pool not ready; creating");
+                    (pool.cheap_clone(), coord.cheap_clone())
+                }
                 Ready(pool) => return Ok(pool.clone()),
             }
         };
 
         // self is `Created` and needs to have setup run
+        warn!(self.logger, "pool_state: setting up pool");
         let migrated = coord.setup_bg(self.cheap_clone())?;
+        warn!(self.logger, "pool_state: pool is ready");
         if migrated {
             Ok(pool)
         } else {
@@ -1329,6 +1335,7 @@ impl PoolInner {
 
 pub const MIGRATIONS: EmbeddedMigrations = embed_migrations!("./migrations");
 
+#[derive(Debug)]
 struct MigrationCount {
     old: usize,
     new: usize,
@@ -1452,6 +1459,31 @@ impl PoolCoordinator {
     /// code that does _not_ hold the migration lock as it will otherwise
     /// deadlock
     fn propagate(&self, pool: &PoolInner, count: MigrationCount) -> Result<(), StoreError> {
+        #[derive(Debug, QueryableByName)]
+        struct Name {
+            #[diesel(sql_type = Text)]
+            pub name: String,
+        }
+
+        let mut conn = pool.get()?;
+        let db = sql_query("select current_database() as name")
+            .get_result::<Name>(&mut conn)
+            .optional()?;
+        warn!(self.logger, "CURRENT DATABASE {:?}", db);
+
+        match sql_query(
+            "select table_name as name from information_schema.tables where table_schema = 'public' order by 1",
+        )
+        .load::<Name>(&mut conn).optional()? {
+            Some(tables) => {
+                let tables = tables.into_iter().map(|t| t.name).collect::<Vec<_>>();
+                warn!(self.logger, "PUBLIC SCHEMA: tables {:?}", tables);
+            }
+            None => {
+                warn!(self.logger, "PUBLIC SCHEMA: no tables");
+            }
+        }
+
         // We need to remap all these servers into `pool` if the list of
         // tables that are mapped have changed from the code of the previous
         // version. Since dropping and recreating the foreign table
@@ -1547,6 +1579,7 @@ impl PoolCoordinator {
     /// the setup was actually run, i.e. if `pool` was available
     fn setup_bg(self: Arc<Self>, pool: PoolState) -> Result<bool, StoreError> {
         let migrated = graph::spawn_thread("database-setup", move || {
+            std::thread::sleep(Duration::from_secs(1));
             graph::block_on(self.setup(vec![pool.clone()]))
         })
         .join()
@@ -1609,6 +1642,7 @@ impl PoolCoordinator {
                         .cheap_clone()
                         .migrate(servers)
                         .map(|res| (state.cheap_clone(), res))
+                        .inspect(|(state, res)| warn!(state.logger, "MIGRATE RESULT {:?}", res))
                 })
                 .collect::<Vec<_>>();
             join_all(futures)
@@ -1658,6 +1692,10 @@ impl PoolCoordinator {
 
             let migrated = migrate(&pools, self.servers.as_ref()).await?;
 
+            warn!(self.logger, "Sleeping for 5s"; "migrated" => migrated.len());
+            tokio::time::sleep(Duration::from_secs(5)).await;
+            warn!(self.logger, "Waking up");
+
             let propagated = propagate(&self, migrated).await?;
 
             primary.create_cross_shard_views(&self.servers)?;