Do not create timeline along with tenant

test_runner/batch_others/test_pageserver_api.py

@@ -23,9 +23,18 @@ def check_client(client: ZenithPageserverHttpClient, initial_tenant: UUID):
     client.tenant_create(tenant_id)
     assert tenant_id.hex in {t['id'] for t in client.tenant_list()}
 
-    # check its timelines
+    timelines = client.timeline_list(tenant_id)
+    assert len(timelines) == 0, "initial tenant should not have any timelines"
+
+    # create timeline
+    timeline_id = uuid4()
+    client.timeline_create(tenant_id=tenant_id, timeline_id=timeline_id)
+
     timelines = client.timeline_list(tenant_id)
     assert len(timelines) > 0
+
+    # check it is there
+    assert timeline_id.hex in {b['timeline_id'] for b in client.timeline_list(tenant_id)}
     for timeline in timelines:
         timeline_id_str = str(timeline['timeline_id'])
         timeline_details = client.timeline_detail(tenant_id=tenant_id,
@@ -34,13 +43,6 @@ def check_client(client: ZenithPageserverHttpClient, initial_tenant: UUID):
         assert timeline_details['tenant_id'] == tenant_id.hex
         assert timeline_details['timeline_id'] == timeline_id_str
 
-    # create timeline
-    timeline_id = uuid4()
-    client.timeline_create(tenant_id=tenant_id, timeline_id=timeline_id)
-
-    # check it is there
-    assert timeline_id.hex in {b['timeline_id'] for b in client.timeline_list(tenant_id)}
-
 
 def test_pageserver_http_api_client(zenith_simple_env: ZenithEnv):
     env = zenith_simple_env

test_runner/batch_others/test_tenants.py

@@ -15,10 +15,10 @@ def test_tenants_normal_work(zenith_env_builder: ZenithEnvBuilder, with_wal_acce
     tenant_1 = env.zenith_cli.create_tenant()
     tenant_2 = env.zenith_cli.create_tenant()
 
-    env.zenith_cli.create_branch(f'test_tenants_normal_work_with_wal_acceptors{with_wal_acceptors}',
-                                 tenant_id=tenant_1)
-    env.zenith_cli.create_branch(f'test_tenants_normal_work_with_wal_acceptors{with_wal_acceptors}',
-                                 tenant_id=tenant_2)
+    env.zenith_cli.create_timeline(
+        f'test_tenants_normal_work_with_wal_acceptors{with_wal_acceptors}', tenant_id=tenant_1)
+    env.zenith_cli.create_timeline(
+        f'test_tenants_normal_work_with_wal_acceptors{with_wal_acceptors}', tenant_id=tenant_2)
 
     pg_tenant1 = env.postgres.create_start(
         f'test_tenants_normal_work_with_wal_acceptors{with_wal_acceptors}',

test_runner/fixtures/zenith_fixtures.py

@@ -57,6 +57,7 @@ Fn = TypeVar('Fn', bound=Callable[..., Any])
 
 DEFAULT_OUTPUT_DIR = 'test_output'
 DEFAULT_POSTGRES_DIR = 'tmp_install'
+DEFAULT_BRANCH_NAME = 'main'
 
 BASE_PORT = 15000
 WORKER_PORT_NUM = 100
@@ -424,7 +425,7 @@ class ZenithEnvBuilder:
                  num_safekeepers: int = 0,
                  pageserver_auth_enabled: bool = False,
                  rust_log_override: Optional[str] = None,
-                 default_branch_name='main'):
+                 default_branch_name=DEFAULT_BRANCH_NAME):
         self.repo_dir = repo_dir
         self.rust_log_override = rust_log_override
         self.port_distributor = port_distributor
@@ -547,7 +548,6 @@ class ZenithEnv:
         self.rust_log_override = config.rust_log_override
         self.port_distributor = config.port_distributor
         self.s3_mock_server = config.s3_mock_server
-        self.default_branch_name = config.default_branch_name
         self.zenith_cli = ZenithCli(env=self)
         self.postgres = PostgresFactory(self)
         self.safekeepers: List[Safekeeper] = []
@@ -639,7 +639,7 @@ def _shared_simple_env(request: Any, port_distributor) -> Iterator[ZenithEnv]:
         env = builder.init_start()
 
         # For convenience in tests, create a branch from the freshly-initialized cluster.
-        env.zenith_cli.create_branch("empty")
+        env.zenith_cli.create_branch('empty', ancestor_branch_name=DEFAULT_BRANCH_NAME)
 
         yield env
 
@@ -750,20 +750,17 @@ class ZenithPageserverHttpClient(requests.Session):
         assert isinstance(res_json, list)
         return res_json
 
-    def tenant_create(self,
-                      tenant_id: Optional[uuid.UUID] = None,
-                      new_timeline_id: Optional[uuid.UUID] = None) -> Dict[Any, Any]:
+    def tenant_create(self, tenant_id: Optional[uuid.UUID] = None) -> uuid.UUID:
         res = self.post(
             f"http://localhost:{self.port}/v1/tenant",
             json={
                 'new_tenant_id': tenant_id.hex if tenant_id else None,
-                'initial_timeline_id': new_timeline_id.hex if new_timeline_id else None,
             },
         )
         self.verbose_error(res)
-        res_json = res.json()
-        assert isinstance(res_json, dict)
-        return res_json
+        new_tenant_id = res.json()
+        assert isinstance(new_tenant_id, str)
+        return uuid.UUID(new_tenant_id)
 
     def timeline_list(self, tenant_id: uuid.UUID) -> List[Dict[Any, Any]]:
         res = self.get(f"http://localhost:{self.port}/v1/tenant/{tenant_id.hex}/timeline")
@@ -834,8 +831,36 @@ class ZenithCli:
         res.check_returncode()
         return res
 
+    def create_timeline(self,
+                        new_branch_name: str,
+                        tenant_id: Optional[uuid.UUID] = None) -> uuid.UUID:
+        cmd = [
+            'timeline',
+            'create',
+            '--branch-name',
+            new_branch_name,
+            '--tenant-id',
+            (tenant_id or self.env.initial_tenant).hex,
+        ]
+
+        res = self.raw_cli(cmd)
+        res.check_returncode()
+
+        create_timeline_id_extractor = re.compile(r"^Created timeline '(?P<timeline_id>[^']+)'",
+                                                  re.MULTILINE)
+        matches = create_timeline_id_extractor.search(res.stdout)
+
+        created_timeline_id = None
+        if matches is not None:
+            created_timeline_id = matches.group('timeline_id')
+
+        if created_timeline_id is None:
+            raise Exception('could not find timeline id after `zenith timeline create` invocation')
+        else:
+            return uuid.UUID(created_timeline_id)
+
     def create_branch(self,
-                      new_branch_name: str,
+                      new_branch_name: str = DEFAULT_BRANCH_NAME,
                       ancestor_branch_name: Optional[str] = None,
                       tenant_id: Optional[uuid.UUID] = None,
                       ancestor_start_lsn: Optional[str] = None) -> uuid.UUID:
@@ -846,9 +871,9 @@ class ZenithCli:
             new_branch_name,
             '--tenant-id',
             (tenant_id or self.env.initial_tenant).hex,
-            '--ancestor-branch-name',
-            ancestor_branch_name or self.env.default_branch_name,
         ]
+        if ancestor_branch_name is not None:
+            cmd.extend(['--ancestor-branch-name', ancestor_branch_name])
         if ancestor_start_lsn is not None:
             cmd.extend(['--ancestor-start-lsn', ancestor_start_lsn])
 

test_runner/performance/test_bulk_tenant_create.py

@@ -31,7 +31,7 @@ def test_bulk_tenant_create(
         start = timeit.default_timer()
 
         tenant = env.zenith_cli.create_tenant()
-        env.zenith_cli.create_branch(
+        env.zenith_cli.create_timeline(
             f'test_bulk_tenant_create_{tenants_count}_{i}_{use_wal_acceptors}', tenant_id=tenant)
 
         # FIXME: We used to start new safekeepers here. Did that make sense? Should we do it now?