if dirname.exists() {

                let runs = db.get_all_runs()?;

                // Create list of events, except ones for private

                // repositories.

                let events: Result<Vec<QueuedCiEvent>, PageError> = db

                    .queued_ci_events()?

                    .iter()

                    .filter_map(|id| match db.get_queued_ci_event(id) {

                        Ok(Some(event)) => match event.event() {

                            CiEvent::V1(CiEventV1::Shutdown) => Some(Ok(event)),

                            CiEvent::V1(CiEventV1::BranchCreated { repo, .. })

                            | CiEvent::V1(CiEventV1::BranchUpdated { repo, .. })

                            | CiEvent::V1(CiEventV1::PatchCreated { repo, .. })

                            | CiEvent::V1(CiEventV1::PatchUpdated { repo, .. }) => {

                                if Self::is_public_repo(profile, repo) {

                                    Some(Ok(event))

                                } else {

                                    None

                                }

                            _ => None,

                        },

                        Ok(None) => None, // Event is (no longer?) in database.

                        Err(_) => None,   // We ignore error here on purpose.

                    })

                    .collect();

                let mut events = events?;

                events.sort_by_cached_key(|e| e.timestamp().to_string());

                let data = PageData {

                    timestamp: now()?,

                    ci_broker_version: env!("CARGO_PKG_VERSION"),

                    ci_broker_git_commit: env!("GIT_HEAD"),

                    node_alias: self.node_alias.clone(),

                    runs: HashMap::from_iter(

                        runs.iter()

                            .map(|run| (run.broker_run_id().clone(), run.clone())),

                    ),

                    events,

                    broker_event_counter: 0,

                    latest_broker_event: None,

                    latest_ci_run: None,

                };

                let nameless = String::from("nameless repo");

                // We avoid writing while keeping the lock, to reduce

                // contention.

                let (status, repos) = {

                    let status = data.status_page_as_html()?.to_string();

                    let mut repos = vec![];

                    for (_, rid) in data.repos() {

                        let basename = rid_to_basename(rid);

                        let filename = dirname.join(format!("{basename}.html"));

                        let alias = data.repo_alias(rid).unwrap_or(nameless.clone());

                        let repopage = data.per_repo_page_as_html(rid, &alias, &data.timestamp);

                        repos.push((filename, repopage.to_string()));

                    }

                    (status, repos)

                };

                let filename = dirname.join("index.html");

                Self::write_file(&filename, &status)?;

                for (filename, repopage) in repos {

                    Self::write_file(&filename, &repopage)?;

                }

                let filename = dirname.join(STATUS_JSON);

                let json = data.status_page_as_json()?;

                Self::write_file(&filename, &json)?;

                let filename = dirname.join(BROKER_RSS);

                let channel = data.status_as_rss()?;

                let rss = channel.to_string();

                Self::write_file(&filename, &rss)?;

                let filename = dirname.join(FAILURE_RSS);

                let channel = data.failed_as_rss()?;

                let rss = channel.to_string();

                Self::write_file(&filename, &rss)?;

                let filename = dirname.join(UNFINISHED_RSS);

                let channel = data.unfinished_as_rss()?;

                let rss = channel.to_string();

                Self::write_file(&filename, &rss)?;

            }