feat: Return UUID when creating a database

Seems polite and is useful for some test setup

generated_types/protos/influxdata/iox/management/v1/service.proto

@@ -157,7 +157,9 @@ message CreateDatabaseRequest {
   DatabaseRules rules = 1;
 }
 
-message CreateDatabaseResponse {}
+message CreateDatabaseResponse {
+  bytes uuid = 1;
+}
 
 // Update a database.
 message UpdateDatabaseRequest {

influxdb_iox/src/commands/database.rs

@@ -219,7 +219,7 @@ pub async fn command(connection: Connection, config: Config) -> Result<()> {
             let mut client = management::Client::new(connection);
             #[allow(deprecated)]
             let rules = DatabaseRules {
-                name: command.name,
+                name: command.name.clone(),
                 lifecycle_rules: Some(LifecycleRules {
                     buffer_size_soft: command.buffer_size_soft as _,
                     buffer_size_hard: command.buffer_size_hard as _,
@@ -253,9 +253,9 @@ pub async fn command(connection: Connection, config: Config) -> Result<()> {
                 ..Default::default()
             };
 
-            client.create_database(rules).await?;
+            let uuid = client.create_database(rules).await?;
 
-            println!("Ok");
+            println!("Created database {} ({})", command.name, uuid);
         }
         Command::List(list) => {
             let mut client = management::Client::new(connection);

influxdb_iox/src/influxdb_ioxd/server_type/database/rpc/management.rs

@@ -128,18 +128,28 @@ where
                 description: e.to_string(),
             })?;
 
-        match self.server.create_database(provided_rules).await {
-            Ok(_) => Ok(Response::new(CreateDatabaseResponse {})),
-            Err(Error::DatabaseAlreadyExists { db_name }) => {
-                return Err(AlreadyExists {
+        let database = self
+            .server
+            .create_database(provided_rules)
+            .await
+            .map_err(|e| match e {
+                Error::DatabaseAlreadyExists { db_name } => AlreadyExists {
                     resource_type: "database".to_string(),
                     resource_name: db_name,
                     ..Default::default()
                 }
-                .into())
-            }
-            Err(e) => Err(default_server_error_handler(e)),
-        }
+                .into(),
+                _ => default_server_error_handler(e),
+            })?;
+
+        let uuid = database
+            .provided_rules()
+            .expect("Database should be initialized or an error should have been returned")
+            .uuid();
+
+        Ok(Response::new(CreateDatabaseResponse {
+            uuid: uuid.as_bytes().to_vec(),
+        }))
     }
 
     async fn update_database(

influxdb_iox/tests/end_to_end_cases/management_cli.rs

@@ -85,7 +85,7 @@ async fn test_create_database() {
         .arg(addr)
         .assert()
         .success()
-        .stdout(predicate::str::contains("Ok"));
+        .stdout(predicate::str::contains(format!("Created database {}", db)));
 
     // Listing the databases includes the newly created database
     Command::cargo_bin("influxdb_iox")
@@ -136,7 +136,7 @@ async fn test_create_database_size() {
         .arg(addr)
         .assert()
         .success()
-        .stdout(predicate::str::contains("Ok"));
+        .stdout(predicate::str::contains("Created"));
 
     Command::cargo_bin("influxdb_iox")
         .unwrap()
@@ -170,7 +170,7 @@ async fn test_create_database_immutable() {
         .arg(addr)
         .assert()
         .success()
-        .stdout(predicate::str::contains("Ok"));
+        .stdout(predicate::str::contains("Created"));
 
     Command::cargo_bin("influxdb_iox")
         .unwrap()
@@ -219,7 +219,7 @@ async fn delete_database() {
         .arg(addr)
         .assert()
         .success()
-        .stdout(predicate::str::contains("Ok"));
+        .stdout(predicate::str::contains("Created"));
 
     // Listing the databases includes the newly created database
     Command::cargo_bin("influxdb_iox")
@@ -310,7 +310,7 @@ async fn delete_database() {
         .arg(addr)
         .assert()
         .success()
-        .stdout(predicate::str::contains("Ok"));
+        .stdout(predicate::str::contains("Created"));
 
     // The newly-created database will be in the active list
     Command::cargo_bin("influxdb_iox")

influxdb_iox/tests/end_to_end_cases/read_cli.rs

@@ -57,7 +57,7 @@ async fn create_database(db_name: &str, addr: &str) {
         .arg(addr)
         .assert()
         .success()
-        .stdout(predicate::str::contains("Ok"));
+        .stdout(predicate::str::contains("Created"));
 
     let lp_data = vec![
         "cpu,region=west user=23.2 100",

influxdb_iox/tests/end_to_end_cases/scenario.rs

@@ -439,7 +439,8 @@ impl DatabaseBuilder {
                 routing_rules,
                 write_buffer_connection: self.write_buffer,
             })
-            .await
+            .await?;
+        Ok(())
     }
 
     // Build a database
@@ -601,7 +602,7 @@ pub async fn fixture_broken_catalog(db_name: &str) -> ServerFixture {
     // Create database with corrupted catalog
     //
 
-    fixture
+    let uuid = fixture
         .management_client()
         .create_database(DatabaseRules {
             name: db_name.to_string(),
@@ -612,22 +613,8 @@ pub async fn fixture_broken_catalog(db_name: &str) -> ServerFixture {
 
     let mut path = fixture.dir().to_path_buf();
     path.push(server_id.to_string());
-    path.push(db_name);
-    let mut generations: Vec<_> = std::fs::read_dir(path.clone())
-        .unwrap()
-        .flatten()
-        .filter_map(|entry| {
-            let path = entry.path();
-            path.is_dir().then(|| path)
-        })
-        .collect();
-    assert_eq!(
-        generations.len(),
-        1,
-        "unexpected database generations {:?}",
-        generations
-    );
-    let mut path = generations.pop().unwrap();
+    path.push(uuid.to_string());
+
     path.push("transactions");
     path.push("00000000000000000001");
     std::fs::create_dir(path.clone()).unwrap();

influxdb_iox/tests/end_to_end_cases/write_cli.rs

@@ -25,7 +25,7 @@ async fn create_database(db_name: &str, addr: &str) {
         .arg(addr)
         .assert()
         .success()
-        .stdout(predicate::str::contains("Ok"));
+        .stdout(predicate::str::contains("Created"));
 }
 
 async fn test_write(db_name: &str, addr: &str) {

influxdb_iox_client/src/client/management.rs

@@ -63,6 +63,10 @@ pub enum CreateDatabaseError {
     /// Client received an unexpected error from the server
     #[error("Unexpected server error: {}: {}", .0.code(), .0.message())]
     ServerError(tonic::Status),
+
+    /// UUID returned as bytes from server could not be converted to a `Uuid`
+    #[error("Invalid UUID: {}: {:?}", .0, .0)]
+    InvalidUuid(uuid::Error),
 }
 
 /// Errors returned by Client::update_database
@@ -535,8 +539,9 @@ impl Client {
     pub async fn create_database(
         &mut self,
         rules: DatabaseRules,
-    ) -> Result<(), CreateDatabaseError> {
-        self.inner
+    ) -> Result<Uuid, CreateDatabaseError> {
+        let response = self
+            .inner
             .create_database(CreateDatabaseRequest { rules: Some(rules) })
             .await
             .map_err(|status| match status.code() {
@@ -547,7 +552,10 @@ impl Client {
                 _ => CreateDatabaseError::ServerError(status),
             })?;
 
-        Ok(())
+        let uuid = Uuid::from_slice(&response.into_inner().uuid)
+            .map_err(CreateDatabaseError::InvalidUuid)?;
+
+        Ok(uuid)
     }
 
     /// Updates the configuration for a database.

server/src/lib.rs

@@ -671,7 +671,7 @@ where
     ///
     /// Waits until the database has initialized or failed to do so
     pub async fn create_database(&self, rules: ProvidedDatabaseRules) -> Result<Arc<Database>> {
-        let uuid = Uuid::new_v4();
+        let uuid = rules.uuid();
         let db_name = rules.db_name();
 
         // Wait for exclusive access to mutate server state
@@ -682,13 +682,11 @@ where
             let state = self.shared.state.read();
             let initialized = state.initialized()?;
 
-            if let Some(existing) = initialized.databases.get(db_name) {
-                if let Some(init_error) = existing.init_error() {
-                    if !matches!(&*init_error, database::InitError::NoActiveDatabase) {
-                        return DatabaseAlreadyExists { db_name }.fail();
-                    }
-                }
-            }
+            ensure!(
+                !initialized.databases.contains_key(db_name),
+                DatabaseAlreadyExists { db_name }
+            );
+
             initialized.server_id
         };