Function server

apps/hash-graph/src/subcommand/server.rs:368–488

(mut args: ServerArgs)

    reason = "Sequential startup flow, no natural split point"
)]
pub async fn server(mut args: ServerArgs) -> Result<(), Report<GraphError>> {
    if args.healthcheck.healthcheck {
        return wait_healthcheck(
            || healthcheck(args.config.http_address.clone()),
            &args.healthcheck,
        )
        .await
        .change_context(GraphError);
    }

    let pool = PostgresStorePool::new(
        &args.db_info,
        &args.db_pool_config,
        NoTls,
        PostgresStoreSettings {
            validate_links: !args.config.skip_link_validation,
            skip_embedding_creation: args.config.skip_embedding_creation,
            filter_protection: if args.config.skip_filter_protection {
                PropertyProtectionFilterConfig::new()
            } else {
                PropertyProtectionFilterConfig::hash_default()
            },
        },
    )
    .await
    .change_context(GraphError)
    .map_err(|report| {
        tracing::error!(error = ?report, "Failed to connect to database");
        report
    })?;

    // Just test the connection; we don't need to use the store
    _ = pool
        .acquire(None)
        .await
        .change_context(GraphError)
        .attach("Connection to database failed")?;

    let lifecycle = ServerLifecycle::new();

    if args.embed_admin {
        start_admin_server(pool.clone(), args.admin, &lifecycle);
    }

    if args.embed_type_fetcher {
        start_type_fetcher(args.type_fetcher.clone(), &lifecycle);
    }

    let pool = FetchingPool::new(
        pool,
        (
            args.type_fetcher.address.type_fetcher_host,
            args.type_fetcher.address.type_fetcher_port,
        ),
        DomainValidator::new(args.config.allowed_url_domain.clone()),
    );

    let log_queries = args.config.log_queries.take();