12633507883

Committed 06 Jan 2025 01:36PM UTC coverage: 90.602% (+0.04%) from 90.56%

Build # 12633507883

Build Type

Pull #1006

github

Committed by

web-flow

Commit Message

Merge a30730161 into 071ba4e63

Pull Request Pull Request #1006: Migrate-pro-api

Run Details

537 of 577 new or added lines in 10 files covered. (93.07%)

221 existing lines in 12 files now uncovered.

133569 of 147424 relevant lines covered (90.6%)

54601.07 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/services/src/api/cli/add_from_directory.rs

use crate::datasets::storage::{DatasetDb, DatasetDefinition};
use crate::error::Result;
use crate::layers::external::TypedDataProviderDefinition;
use crate::layers::storage::LayerProviderDb;
use crate::pro::permissions::{Permission, PermissionDb, Role};
use geoengine_datatypes::dataset::DatasetId;
use geoengine_datatypes::error::BoxedResultExt;
use geoengine_datatypes::util::helpers::ge_report;
use log::{error, info, warn};
use std::{
    fs::{self, DirEntry, File},
    io::BufReader,
    path::PathBuf,
};

pub async fn add_datasets_from_directory<D: DatasetDb + PermissionDb>(
    dataset_db: &mut D,
    file_path: PathBuf,
) {
    async fn add_dataset_definition_from_dir_entry<D: DatasetDb + PermissionDb>(
        db: &mut D,
        entry: &DirEntry,
    ) -> Result<()> {
        let def: DatasetDefinition =
            serde_json::from_reader(BufReader::new(File::open(entry.path())?))?;

        let dataset_id: DatasetId = db
            .add_dataset(def.properties.clone(), def.meta_data.clone())
            .await?
            .id;

        db.add_permission(
            Role::registered_user_role_id(),
            dataset_id,
            Permission::Read,
        )
        .await
        .boxed_context(crate::error::PermissionDb)?;

        db.add_permission(Role::anonymous_role_id(), dataset_id, Permission::Read)
            .await
            .boxed_context(crate::error::PermissionDb)?;

        Ok(())
    }

    let Ok(dir) = fs::read_dir(file_path) else {
        warn!("Skipped adding datasets from directory because it can't be read");
        return;
    };

    for entry in dir {
        if let Ok(entry) = entry {
            if let Err(e) = add_dataset_definition_from_dir_entry(dataset_db, &entry).await {
                warn!(
                    "Skipped adding dataset from directory entry: {:?} error: {}",
                    entry,
                    ge_report(e)
                );
            }
        } else {
            warn!("Skipped adding dataset from directory entry: {:?}", entry);
        }
    }
}

// TODO: move to layers source dir
pub async fn add_providers_from_directory<D: LayerProviderDb>(db: &mut D, base_path: PathBuf) {
    async fn add_provider_definition_from_dir_entry<D: LayerProviderDb>(
        db: &mut D,
        entry: &DirEntry,
    ) -> Result<()> {
        let def: TypedDataProviderDefinition =
            serde_json::from_reader(BufReader::new(File::open(entry.path())?))?;

        db.add_layer_provider(def).await?; // TODO: add as system user
        Ok(())
    }

    let Ok(dir) = fs::read_dir(&base_path) else {
        error!(
            "Skipped adding providers from directory `{:?}` because it can't be read",
            base_path
        );
        return;
    };

    for entry in dir {
        match entry {
            Ok(entry) if entry.path().is_file() => {
                match add_provider_definition_from_dir_entry(db, &entry).await {
                    Ok(()) => info!("Added provider from file `{:?}`", entry.path()),
                    Err(e) => {
                        warn!(
                            "Skipped adding provider from file `{:?}` error: `{:?}`",
                            entry.path(),
                            e
                        );
                    }
                }
            }
            Err(e) => {
                warn!("Skipped adding provider from directory entry `{:?}`", e);
            }
            _ => {}
        }
    }
}

1	use crate::datasets::storage::{DatasetDb, DatasetDefinition};
2	use crate::error::Result;
3	use crate::layers::external::TypedDataProviderDefinition;
4	use crate::layers::storage::LayerProviderDb;
5	use crate::pro::permissions::{Permission, PermissionDb, Role};
6	use geoengine_datatypes::dataset::DatasetId;
7	use geoengine_datatypes::error::BoxedResultExt;
8	use geoengine_datatypes::util::helpers::ge_report;
9	use log::{error, info, warn};
10	use std::{
11	fs::{self, DirEntry, File},
12	io::BufReader,
13	path::PathBuf,
14	};
15
NEW 16	pub async fn add_datasets_from_directory<D: DatasetDb + PermissionDb>(	×
NEW 17	dataset_db: &mut D,	×
NEW 18	file_path: PathBuf,	×
NEW 19	) {	×
NEW 20	async fn add_dataset_definition_from_dir_entry<D: DatasetDb + PermissionDb>(	×
21	db: &mut D,	×
22	entry: &DirEntry,	×
23	) -> Result<()> {	×
24	let def: DatasetDefinition =	×
25	serde_json::from_reader(BufReader::new(File::open(entry.path())?))?;	×
26
NEW 27	let dataset_id: DatasetId = db	×
NEW 28	.add_dataset(def.properties.clone(), def.meta_data.clone())	×
NEW 29	.await?	×
30	.id;
31
NEW 32	db.add_permission(	×
NEW 33	Role::registered_user_role_id(),	×
NEW 34	dataset_id,	×
NEW 35	Permission::Read,	×
NEW 36	)	×
NEW 37	.await	×
NEW 38	.boxed_context(crate::error::PermissionDb)?;	×
39
NEW 40	db.add_permission(Role::anonymous_role_id(), dataset_id, Permission::Read)	×
NEW 41	.await	×
NEW 42	.boxed_context(crate::error::PermissionDb)?;	×
43
44	Ok(())	×
45	}	×
46
NEW 47	let Ok(dir) = fs::read_dir(file_path) else {	×
NEW 48	warn!("Skipped adding datasets from directory because it can't be read");	×
UNCOV 49	return;	×
50	};
51
52	for entry in dir {	×
NEW 53	if let Ok(entry) = entry {	×
NEW 54	if let Err(e) = add_dataset_definition_from_dir_entry(dataset_db, &entry).await {	×
NEW 55	warn!(	×
NEW 56	"Skipped adding dataset from directory entry: {:?} error: {}",	×
NEW 57	entry,	×
NEW 58	ge_report(e)	×
59	);
60	}	×
61	} else {
NEW 62	warn!("Skipped adding dataset from directory entry: {:?}", entry);	×
63	}
64	}
65	}	×
66
67	// TODO: move to layers source dir
68	pub async fn add_providers_from_directory<D: LayerProviderDb>(db: &mut D, base_path: PathBuf) {	×
69	async fn add_provider_definition_from_dir_entry<D: LayerProviderDb>(	×
70	db: &mut D,	×
71	entry: &DirEntry,	×
72	) -> Result<()> {	×
73	let def: TypedDataProviderDefinition =	×
74	serde_json::from_reader(BufReader::new(File::open(entry.path())?))?;	×
75
76	db.add_layer_provider(def).await?; // TODO: add as system user	×
77	Ok(())	×
78	}	×
79
80	let Ok(dir) = fs::read_dir(&base_path) else {	×
81	error!(	×
82	"Skipped adding providers from directory `{:?}` because it can't be read",	×
83	base_path
84	);
85	return;	×
86	};
87
88	for entry in dir {	×
89	match entry {	×
90	Ok(entry) if entry.path().is_file() => {	×
91	match add_provider_definition_from_dir_entry(db, &entry).await {	×
92	Ok(()) => info!("Added provider from file `{:?}`", entry.path()),	×
93	Err(e) => {	×
94	warn!(	×
95	"Skipped adding provider from file `{:?}` error: `{:?}`",	×
96	entry.path(),	×
97	e
98	);
99	}
100	}
101	}
102	Err(e) => {	×
103	warn!("Skipped adding provider from directory entry `{:?}`", e);	×
104	}
105	_ => {}	×
106	}
107	}
108	}	×

geo-engine / geoengine / 12633507883

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous