Feature/extension osm reader country dynamic (#1)

* feat: dynamic country_code support

* Binary multi_country ready for PR

* final change done after Damien review

* add --version feature

---------

Co-authored-by: Diego Sindres <diegosindres@MacBookPro.lan>
Co-authored-by: Diego Sindres <diegosindres@MacBook-Pro-de-ODS.local>

Author: 3 people

.DS_Store

@@ -30,8 +30,9 @@ jobs:
 
     - name: Create Release
       # https://github.com/softprops/action-gh-release
+      if: github.event_name == 'push'
       uses: softprops/action-gh-release@v1
       with:
         files: target/x86_64-unknown-linux-musl/release/*
-        tag_name: v1.1.0
-        release_name: Release v1.1.0
+        tag_name: v1.2.0
+        release_name: Release v1.2.0

.github/workflows/rust.yml

@@ -1,5 +1,4 @@
 .envrc
 .idea
 target
-
-
+.DS_Store

.gitignore

@@ -1,6 +1,6 @@
 [package]
 name = "pbf_history_reader"
-version = "0.1.0"
+version = "1.2.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

Cargo.lock

@@ -1,7 +1,8 @@
 # OpenStreetMap PBF history parser
+
 This Rust program:
 - parses OSM [history files from Geofabrik](https://osm-internal.download.geofabrik.de)
-- then creates a postgres `osm.history` table with the following fields:
+- then creates a postgres `{schema}.history` table with the following fields:
   - id (negative IDs are for relations)
   - timestamps
   - changesets
@@ -10,13 +11,41 @@ This Rust program:
   - users_number
   - versions_number
 
+The database schema is dynamically computed based on the country code (see Usage section below).
+
+---
+
+## Usage
+
+### Basic usage (France, default)
+```bash
+./pbf_history_reader /path/to/history.osh.pbf /path/to/tag_list.txt
+```
+Writes to schema `osm`.
+
+### With country code (multi-country support)
+```bash
+./pbf_history_reader /path/to/history.osh.pbf /path/to/tag_list.txt nz
+```
+Writes to schema `osm_nz`.
+```bash
+./pbf_history_reader /path/to/history.osh.pbf /path/to/tag_list.txt au
+```
+Writes to schema `osm_au`.
+
+### To know the version
+```bash
+./pbf_history_reader --version
+```
+
+---
 
 ## Configure your rust environment
+
 ### Tools
 
 Install `rust` and `cargo` with:
-
-```
+```bash
 curl https://sh.rustup.rs -sSf | sh
 ```
 
@@ -26,74 +55,108 @@ curl https://sh.rustup.rs -sSf | sh
 
 #### Building the executable file
 from the `osm/pbf_history_reader` subfolder
-````
+```
 cargo build
-````
+```
 
 It creates an executable file in `./target/debug/` directory (by default, `cargo` builds in debug mode)
 
 #### Building & running the executable file
-
-````
+```
 cargo run
-````
+```
 
 This command builds then run the executable file.
 
 #### Building for release
-
 ```
 cargo build --release
 ```
 
 It creates an executable file in `./target/release/` directory. With this option, the program is optimized to run
 faster.
 
-### Cross-compilation
+---
+
+## Cross-compilation
 
 - Install a cross toolchain:
 
 On mac:
-
 ```
 brew tap SergioBenitez/osxct
 brew install x86_64-unknown-linux-gnu
 ```
 
 then specify it in cargo config file `.cargo/config.toml`:
-
 ```bash
 # .cargo/config.toml
 [target.x86_64-unknown-linux-gnu]
 linker = "/opt/homebrew/bin/x86_64-unknown-linux-gnu-gcc"
 ```
 
 - Specify the compilation target:
-
 ```
 rustup target add x86_64-unknown-linux-gnu
 ```
 
 - Compile (in release):
-
 ```
 cargo build --target x86_64-unknown-linux-gnu -v --release
 ```
 
 The executable file is created in `osm/pbf_history_reader/target/x86_64-unknown-linux-gnu/release` directory
 
-> pbf_history_reader needs several environment variables to work:
-> - DB_NAME
-> - DB_PORT
-> - DB_USER
-> 
-> (DB_NAME, DB_USER and DB_PORT have default values defined in `osm/pbf_history_reader/src/main.rs` file, but you can
-> override them (especially if you are working locally))
-> - DB_HOST
-> - DB_PASSWORD
-> - OSM_ACCOUNT_PASSWORD (for history files)
-> - OSM_ACCOUNT_USER
->
-
-> They can be provided with `env.local` or `.envrc` files (don't forget to pass them to the container
-> in `docker-compose.yml` file)
+---
+
+## Environment variables
+
+pbf_history_reader needs several environment variables to work:
+- `DB_HOST` (required)
+- `DB_PASSWORD` (required)
+- `DB_NAME` (default: `dataseed`)
+- `DB_PORT` (default: `5432`)
+- `DB_USER` (default: `dataseed`)
+- `OSM_ACCOUNT_USER` (for history files)
+- `OSM_ACCOUNT_PASSWORD` (for history files)
+
+They can be provided with `env.local` or `.envrc` files (don't forget to pass them to the container
+in `docker-compose.yml` file)
+
+---
+
+## Release
+
+### How to release a new version
+
+1. **Update the version tag in `.github/workflows/rust.yml` and in `Cargo.toml`**
+   
+   Edit the `tag_name` and `release_name` fields:
+```yaml
+   - name: Create Release
+     uses: softprops/action-gh-release@v1
+     with:
+       files: target/x86_64-unknown-linux-musl/release/*
+       tag_name: v1.2.0        # ← update this
+       release_name: Release v1.2.0  # ← and this
+```
+
+   Edit the `version` fields:
+```
+   version = "1.2.0". # <- update this
+```
+
+2. **Commit and push to master**
+```bash
+   git add .github/workflows/rust.yml
+   git commit -m "chore: bump version to v1.2.0"
+   git push origin master
+```
+
+3. **GitHub Actions will automatically:**
+   - Build the binary for `x86_64-unknown-linux-musl`
+   - Create a GitHub Release `v1.3.0` with the binary attached
+   - The binary will be available at:
+```
+     https://github.com/opendatasoft/osm-pbf-history-reader/releases/download/v1.2.0/pbf_history_reader
+```

Cargo.toml

@@ -10,26 +10,53 @@ mod infos;
 mod load_infos;
 mod postgres_client;
 
-const SCHEMA: &str = "OSM";
 const TABLE: &str = "HISTORY";
 
 fn main() {
+    let args: Vec<String> = env::args().collect();
+    if args.len() > 1 && args[1] == "--version" {
+        println!("pbf_history_reader version: {}", env!("CARGO_PKG_VERSION"));
+        return;
+    }
     let host: String = env::var("DB_HOST").expect("$DB_HOST is not set");
     let password: String = env::var("DB_PASSWORD").expect("$DB_PASSWORD is not set");
     let user: String = env::var("DB_USER").unwrap_or(String::from("dataseed"));
     let dbname: String = env::var("DB_NAME").unwrap_or(String::from("dataseed"));
     let port: String = env::var("DB_PORT").unwrap_or(String::from("5432"));
 
     let args: Vec<String> = env::args().collect();
+    
+    if args.len() < 3 {
+        panic!("Usage: {} <history_pbf> <tag_list> [country_code] (or --version)", args[0]);
+    }
+
     let history_file_path_str = &args[1];
     let history_file_path = Path::new(history_file_path_str);
 
     let tag_list_file_path_str = &args[2];
     let tag_list_file_path = Path::new(tag_list_file_path_str);
 
+    // SECURITY if no 4th argument is send (old fr pipeline hardcoded)
+    // If no country_code OR country_code = fr --> schema = osm
+    // consistency with old version
+    let country_code = args.get(3).cloned().unwrap_or_else(|| String::from("fr"));
+
+    if country_code.len() != 2 {
+        panic!(
+            "Invalid country_code '{}': must be exactly 2 letters (e.g., 'fr', 'au', 'nz')",
+            country_code
+        );
+    }
+
+    let schema = if country_code == "fr" { 
+        String::from("osm") 
+    } else { 
+        format!("osm_{}", country_code) 
+    };
+
     for path in [history_file_path, tag_list_file_path] {
         if !path.exists() {
-            panic!("Tag list file {} does not exists", path.display())
+            panic!("File {} does not exist", path.display())
         }
     }
 
@@ -52,26 +79,27 @@ fn main() {
     }
     let tag_list: HashSet<&str> = tag_list_string.iter().map(|s| s.as_str()).collect();
 
-    println!("{:?}", tag_list);
+    println!("Tags to filter: {:?}", tag_list);
+    println!("Processing for country: {} (SQL schema: {})", country_code, schema);
 
     let now = Instant::now();
     let mut db_client = postgres_client::connect(&host, &user, &password, &dbname, &port);
     let db_connection_time = Instant::now();
 
-    postgres_client::create_schema(&mut db_client, SCHEMA);
+    postgres_client::create_schema(&mut db_client, &schema);
     let db_schema_creation_time = Instant::now();
 
-    postgres_client::create_table_history(&mut db_client, SCHEMA, TABLE);
+    postgres_client::create_table_history(&mut db_client, &schema, TABLE);
     let db_history_creation_time = Instant::now();
 
     let elements_infos =
         history_processing::process_history(history_file_path.to_str().unwrap(), tag_list);
     let process_history_time = Instant::now();
 
-    postgres_client::add_index(&mut db_client, SCHEMA, TABLE, "id");
+    postgres_client::add_index(&mut db_client, &schema, TABLE, "id");
     let indexing_time = Instant::now();
 
-    load_infos::load(&mut db_client, SCHEMA, TABLE, elements_infos);
+    load_infos::load(&mut db_client, &schema, TABLE, elements_infos);
     let insert_history_time = Instant::now();
 
     println!(
@@ -91,4 +119,4 @@ fn main() {
         insert_history_time.duration_since(indexing_time),
         insert_history_time.duration_since(now),
     )
-}
+}