Method start

src/pglite/server.rs:315–385

Install the runtime if needed, initialize the cluster, and start serving.

(self)

    /// Install the runtime if needed, initialize the cluster, and start serving.
    pub fn start(self) -> Result<PgliteServer> {
        self.postgres_config.validate()?;
        self.startup_config.validate()?;
        #[cfg(feature = "extensions")]
        let extensions = resolve_extension_set(&self.extensions)?;
        let postgres_config = self.postgres_config.clone();
        let startup_config = self.startup_config.clone();

        let prepared_root = {
            let _phase = timing::phase("server.root_prepare");
            match self.root {
                ServerRoot::Path(root) => {
                    let _phase = timing::phase("server.root_prepare.path");
                    let plan = RootPlan::new(RootTarget::Path(root), RootSource::Template);
                    #[cfg(feature = "extensions")]
                    let plan = plan.with_extensions(extensions.clone(), postgres_config.clone());
                    prepare_root(plan)?
                }
                ServerRoot::Temporary { template_cache } => {
                    let source = if template_cache {
                        RootSource::Template
                    } else {
                        RootSource::FreshInitdb
                    };
                    let phase = if template_cache {
                        "server.root_prepare.temporary_cached"
                    } else {
                        "server.root_prepare.temporary_fresh"
                    };
                    let _phase = timing::phase(phase);
                    let plan = RootPlan::new(RootTarget::Temporary, source);
                    #[cfg(feature = "extensions")]
                    let plan = plan.with_extensions(extensions.clone(), postgres_config.clone());
                    run_blocking("pglite-template-cache", move || prepare_root(plan))?
                }
            }
        };
        let PreparedRoot {
            root,
            temp_dir,
            root_lock,
            outcome,
        } = prepared_root;

        let shutdown = Arc::new(AtomicBool::new(false));
        let proxy = {
            let _phase = timing::phase("server.proxy_create");
            PgliteProxy::new(root.clone()).with_prepared_root(outcome)
        };
        let proxy = proxy
            .with_postgres_config(postgres_config)
            .with_startup_config(startup_config.clone());
        #[cfg(feature = "extensions")]
        let proxy = proxy.with_extensions(extensions);

        let (endpoint, handle) = match self.endpoint {
            ServerEndpointConfig::Tcp(addr) => start_tcp(proxy, addr, shutdown.clone())?,
            #[cfg(unix)]