614 lines
20 KiB
Rust
614 lines
20 KiB
Rust
//! Instance grouping backed by a standalone JSON file in the app's settings
|
|
//! directory, next to `settings.json`.
|
|
//!
|
|
//! Groups used to live in SQLite (`instance_groups` /
|
|
//! `instance_group_memberships`). That layout could not express membership for
|
|
//! JSON-backed instances (`local:` ids, i.e. every `.minecraft` and
|
|
//! multi-library instance) because they have no row in the `instances` table,
|
|
//! and it duplicated membership into the per-instance sidecars. This module is
|
|
//! the single source of truth instead; the SQL tables are left untouched but
|
|
//! are no longer read or written (they are only read once, at import time).
|
|
|
|
use crate::state::State;
|
|
use serde::{Deserialize, Serialize};
|
|
use std::collections::{HashMap, HashSet};
|
|
use std::fs;
|
|
use std::path::PathBuf;
|
|
use std::sync::{OnceLock, RwLock};
|
|
use tracing::{info, warn};
|
|
|
|
pub const INSTANCE_GROUPS_FILE_NAME: &str = "instance_groups.json";
|
|
|
|
/// Current `instance_groups.json` schema version.
|
|
pub const INSTANCE_GROUPS_SCHEMA_VERSION: u32 = 1;
|
|
|
|
pub const FAVORITES_GROUP_ID: &str = "group:favorites";
|
|
const FAVORITES_GROUP_NAME: &str = "Pinned";
|
|
|
|
#[derive(Clone, Debug, Serialize, Deserialize)]
|
|
pub struct GroupDefinition {
|
|
pub id: String,
|
|
pub name: String,
|
|
}
|
|
|
|
/// On-disk shape. The order of `groups` *is* the display order, so no
|
|
/// `display_order` field is needed: the public API only ever communicates
|
|
/// ordering through the order of `list()` and `set_order()`.
|
|
#[derive(Clone, Debug, Serialize, Deserialize)]
|
|
pub struct InstanceGroupsFile {
|
|
#[serde(default)]
|
|
pub schema_version: u32,
|
|
#[serde(default)]
|
|
pub groups: Vec<GroupDefinition>,
|
|
/// instance id -> group ids.
|
|
#[serde(default)]
|
|
pub memberships: HashMap<String, Vec<String>>,
|
|
}
|
|
|
|
impl Default for InstanceGroupsFile {
|
|
fn default() -> Self {
|
|
Self {
|
|
schema_version: INSTANCE_GROUPS_SCHEMA_VERSION,
|
|
groups: vec![GroupDefinition {
|
|
id: FAVORITES_GROUP_ID.to_string(),
|
|
name: FAVORITES_GROUP_NAME.to_string(),
|
|
}],
|
|
memberships: HashMap::new(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl InstanceGroupsFile {
|
|
fn has_group(&self, id: &str) -> bool {
|
|
self.groups.iter().any(|group| group.id == id)
|
|
}
|
|
|
|
/// Guarantees the favorites sentinel exists and sits first, drops
|
|
/// memberships pointing at groups that no longer exist, and drops instances
|
|
/// left with no groups at all.
|
|
fn normalize(&mut self) {
|
|
self.schema_version = INSTANCE_GROUPS_SCHEMA_VERSION;
|
|
|
|
match self.groups.iter().position(|g| g.id == FAVORITES_GROUP_ID) {
|
|
Some(0) => {}
|
|
Some(index) => {
|
|
let favorites = self.groups.remove(index);
|
|
self.groups.insert(0, favorites);
|
|
}
|
|
None => self.groups.insert(
|
|
0,
|
|
GroupDefinition {
|
|
id: FAVORITES_GROUP_ID.to_string(),
|
|
name: FAVORITES_GROUP_NAME.to_string(),
|
|
},
|
|
),
|
|
}
|
|
|
|
let known = self
|
|
.groups
|
|
.iter()
|
|
.map(|group| group.id.clone())
|
|
.collect::<HashSet<_>>();
|
|
|
|
for group_ids in self.memberships.values_mut() {
|
|
let mut seen = HashSet::new();
|
|
group_ids
|
|
.retain(|id| known.contains(id) && seen.insert(id.clone()));
|
|
}
|
|
self.memberships
|
|
.retain(|_, group_ids| !group_ids.is_empty());
|
|
}
|
|
}
|
|
|
|
static STORE: OnceLock<RwLock<InstanceGroupsFile>> = OnceLock::new();
|
|
|
|
fn file_path() -> Option<PathBuf> {
|
|
let state = State::get_if_initialized()?;
|
|
Some(
|
|
state
|
|
.directories
|
|
.settings_dir
|
|
.join(INSTANCE_GROUPS_FILE_NAME),
|
|
)
|
|
}
|
|
|
|
/// Reads the store from disk, or `None` when it has never been written.
|
|
fn read_from_disk() -> Option<InstanceGroupsFile> {
|
|
let path = file_path()?;
|
|
if !path.exists() {
|
|
return None;
|
|
}
|
|
match fs::read_to_string(&path)
|
|
.map_err(|e| e.to_string())
|
|
.and_then(|content| {
|
|
serde_json::from_str::<InstanceGroupsFile>(&content)
|
|
.map_err(|e| e.to_string())
|
|
}) {
|
|
Ok(mut file) => {
|
|
file.normalize();
|
|
Some(file)
|
|
}
|
|
Err(error) => {
|
|
// A corrupt file must not wipe the user's groups silently on the
|
|
// next write, so bail out to an empty store without touching disk.
|
|
warn!("Failed to read {INSTANCE_GROUPS_FILE_NAME}: {error}");
|
|
None
|
|
}
|
|
}
|
|
}
|
|
|
|
fn write_to_disk(file: &InstanceGroupsFile) {
|
|
let Some(path) = file_path() else {
|
|
return;
|
|
};
|
|
let write = serde_json::to_string_pretty(file)
|
|
.map_err(|e| e.to_string())
|
|
.and_then(|content| {
|
|
fs::write(&path, content).map_err(|e| e.to_string())
|
|
});
|
|
if let Err(error) = write {
|
|
warn!("Failed to save {INSTANCE_GROUPS_FILE_NAME}: {error}");
|
|
}
|
|
}
|
|
|
|
fn store() -> &'static RwLock<InstanceGroupsFile> {
|
|
STORE.get_or_init(|| RwLock::new(read_from_disk().unwrap_or_default()))
|
|
}
|
|
|
|
fn with_read<T>(f: impl FnOnce(&InstanceGroupsFile) -> T) -> T {
|
|
let guard = store().read().unwrap_or_else(|e| e.into_inner());
|
|
f(&guard)
|
|
}
|
|
|
|
/// Mutates the store and persists the whole file. `f` returns the instance ids
|
|
/// whose membership changed, so callers can emit the change event.
|
|
fn with_write<T>(f: impl FnOnce(&mut InstanceGroupsFile) -> T) -> T {
|
|
let mut guard = store().write().unwrap_or_else(|e| e.into_inner());
|
|
let result = f(&mut guard);
|
|
guard.normalize();
|
|
write_to_disk(&guard);
|
|
result
|
|
}
|
|
|
|
// ── Reads ───────────────────────────────────────────────────────────────────
|
|
|
|
pub fn list() -> Vec<GroupDefinition> {
|
|
with_read(|file| file.groups.clone())
|
|
}
|
|
|
|
pub fn group_exists(id: &str) -> bool {
|
|
with_read(|file| file.has_group(id))
|
|
}
|
|
|
|
/// Group ids for one instance, in the order they were assigned. Synchronous so
|
|
/// that `instance_metadata_from_instance` can call it.
|
|
pub fn group_ids_for(instance_id: &str) -> Vec<String> {
|
|
with_read(|file| {
|
|
file.memberships
|
|
.get(instance_id)
|
|
.cloned()
|
|
.unwrap_or_default()
|
|
})
|
|
}
|
|
|
|
fn instances_in_group(
|
|
file: &InstanceGroupsFile,
|
|
group_id: &str,
|
|
) -> Vec<String> {
|
|
file.memberships
|
|
.iter()
|
|
.filter(|(_, group_ids)| group_ids.iter().any(|id| id == group_id))
|
|
.map(|(instance_id, _)| instance_id.clone())
|
|
.collect()
|
|
}
|
|
|
|
// ── Writes ──────────────────────────────────────────────────────────────────
|
|
|
|
/// Adds a group at the top of the list, matching the previous SQL behavior
|
|
/// where new groups got the lowest `display_order`. Favorites stays first.
|
|
pub fn create(id: &str, name: &str) {
|
|
with_write(|file| {
|
|
let definition = GroupDefinition {
|
|
id: id.to_string(),
|
|
name: name.to_string(),
|
|
};
|
|
// `normalize` moves favorites back to index 0 afterwards.
|
|
file.groups.insert(0, definition);
|
|
});
|
|
}
|
|
|
|
/// Renames a group, returning the affected instance ids, or `None` when the
|
|
/// group does not exist.
|
|
pub fn rename(id: &str, name: &str) -> Option<Vec<String>> {
|
|
with_write(|file| {
|
|
let group = file.groups.iter_mut().find(|group| group.id == id)?;
|
|
group.name = name.to_string();
|
|
Some(instances_in_group(file, id))
|
|
})
|
|
}
|
|
|
|
/// Deletes a group and strips it from every instance, returning the affected
|
|
/// instance ids, or `None` when the group does not exist.
|
|
pub fn delete(id: &str) -> Option<Vec<String>> {
|
|
with_write(|file| {
|
|
let index = file.groups.iter().position(|group| group.id == id)?;
|
|
let affected = instances_in_group(file, id);
|
|
file.groups.remove(index);
|
|
// `normalize` prunes the now-dangling ids out of `memberships`.
|
|
Some(affected)
|
|
})
|
|
}
|
|
|
|
/// Reorders groups to match `group_ids`. Groups missing from the argument keep
|
|
/// their relative order at the end, so a stale frontend list can never drop a
|
|
/// group. Favorites is pinned first regardless.
|
|
pub fn set_order(group_ids: &[String]) {
|
|
with_write(|file| reorder_groups(&mut file.groups, group_ids));
|
|
}
|
|
|
|
/// Reorders `groups` to match `group_ids`. Groups the argument omits keep their
|
|
/// relative order after the listed ones, so a stale frontend list can never drop
|
|
/// a group. Pure so the ordering rules can be tested without the process-wide
|
|
/// store, which tests would otherwise race over.
|
|
fn reorder_groups(groups: &mut Vec<GroupDefinition>, group_ids: &[String]) {
|
|
let mut remaining = std::mem::take(groups);
|
|
let mut ordered = Vec::with_capacity(remaining.len());
|
|
for id in group_ids {
|
|
if id == FAVORITES_GROUP_ID {
|
|
continue;
|
|
}
|
|
if let Some(index) = remaining.iter().position(|group| &group.id == id)
|
|
{
|
|
ordered.push(remaining.remove(index));
|
|
}
|
|
}
|
|
ordered.extend(remaining);
|
|
*groups = ordered;
|
|
}
|
|
|
|
/// Replaces the group list of each given instance wholesale.
|
|
pub fn set_memberships(updates: &[(String, Vec<String>)]) {
|
|
with_write(|file| {
|
|
for (instance_id, group_ids) in updates {
|
|
if group_ids.is_empty() {
|
|
file.memberships.remove(instance_id);
|
|
} else {
|
|
file.memberships
|
|
.insert(instance_id.clone(), group_ids.clone());
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
/// Replaces the group list of a single instance.
|
|
pub fn set_instance_groups(instance_id: &str, group_ids: &[String]) {
|
|
set_memberships(&[(instance_id.to_string(), group_ids.to_vec())]);
|
|
}
|
|
|
|
/// Looks a group up by name, creating it if absent, and returns its id.
|
|
/// Used by the legacy launcher import, which only knows group names.
|
|
pub fn find_or_create_by_name(name: &str) -> String {
|
|
with_write(|file| {
|
|
if let Some(group) = file.groups.iter().find(|group| group.name == name)
|
|
{
|
|
return group.id.clone();
|
|
}
|
|
let id = uuid::Uuid::new_v4().to_string();
|
|
file.groups.push(GroupDefinition {
|
|
id: id.clone(),
|
|
name: name.to_string(),
|
|
});
|
|
id
|
|
})
|
|
}
|
|
|
|
/// Adds one group to an instance, keeping its existing groups.
|
|
pub fn add_instance_to_group(instance_id: &str, group_id: &str) {
|
|
with_write(|file| {
|
|
let entry =
|
|
file.memberships.entry(instance_id.to_string()).or_default();
|
|
if !entry.iter().any(|id| id == group_id) {
|
|
entry.push(group_id.to_string());
|
|
}
|
|
});
|
|
}
|
|
|
|
/// Drops an instance's membership entry, e.g. after the instance is deleted.
|
|
pub fn forget_instance(instance_id: &str) {
|
|
with_write(|file| {
|
|
file.memberships.remove(instance_id);
|
|
});
|
|
}
|
|
|
|
/// Re-keys an instance's membership, e.g. when a `local:` id changes because the
|
|
/// instance directory moved.
|
|
pub fn rename_instance(old_id: &str, new_id: &str) {
|
|
if old_id == new_id {
|
|
return;
|
|
}
|
|
with_write(|file| {
|
|
if let Some(group_ids) = file.memberships.remove(old_id) {
|
|
file.memberships.insert(new_id.to_string(), group_ids);
|
|
}
|
|
});
|
|
}
|
|
|
|
// ── One-time import ─────────────────────────────────────────────────────────
|
|
|
|
async fn import_sql_groups(
|
|
pool: &sqlx::SqlitePool,
|
|
) -> crate::Result<InstanceGroupsFile> {
|
|
let columns: Vec<String> = sqlx::query_scalar(
|
|
"SELECT name FROM pragma_table_info('instance_groups')",
|
|
)
|
|
.fetch_all(pool)
|
|
.await?;
|
|
let has_column = |name: &str| columns.iter().any(|column| column == name);
|
|
|
|
let mut file = InstanceGroupsFile {
|
|
schema_version: INSTANCE_GROUPS_SCHEMA_VERSION,
|
|
groups: Vec::new(),
|
|
memberships: HashMap::new(),
|
|
};
|
|
|
|
if has_column("id") && has_column("name") {
|
|
let rows = sqlx::query_as::<_, (String, String)>(
|
|
"SELECT id, name FROM instance_groups ORDER BY display_order, name, id",
|
|
)
|
|
.fetch_all(pool)
|
|
.await?;
|
|
for (id, name) in rows {
|
|
file.groups.push(GroupDefinition { id, name });
|
|
}
|
|
|
|
let has_memberships: bool = sqlx::query_scalar(
|
|
"SELECT EXISTS(
|
|
SELECT 1 FROM sqlite_master
|
|
WHERE type = 'table' AND name = 'instance_group_memberships'
|
|
)",
|
|
)
|
|
.fetch_one(pool)
|
|
.await?;
|
|
if has_memberships {
|
|
let memberships = sqlx::query_as::<_, (String, String)>(
|
|
"SELECT instance_id, group_id FROM instance_group_memberships",
|
|
)
|
|
.fetch_all(pool)
|
|
.await?;
|
|
for (instance_id, group_id) in memberships {
|
|
file.memberships
|
|
.entry(instance_id)
|
|
.or_default()
|
|
.push(group_id);
|
|
}
|
|
}
|
|
} else if has_column("instance_id") && has_column("group_name") {
|
|
let rows = sqlx::query_as::<_, (String, String)>(
|
|
"SELECT instance_id, group_name
|
|
FROM instance_groups
|
|
ORDER BY group_name, instance_id",
|
|
)
|
|
.fetch_all(pool)
|
|
.await?;
|
|
let mut group_ids = HashMap::<String, String>::new();
|
|
for (instance_id, group_name) in rows {
|
|
let group_id = group_ids
|
|
.entry(group_name.clone())
|
|
.or_insert_with(|| uuid::Uuid::new_v4().to_string())
|
|
.clone();
|
|
file.memberships
|
|
.entry(instance_id)
|
|
.or_default()
|
|
.push(group_id.clone());
|
|
if !file.groups.iter().any(|group| group.id == group_id) {
|
|
file.groups.push(GroupDefinition {
|
|
id: group_id,
|
|
name: group_name,
|
|
});
|
|
}
|
|
}
|
|
} else if !columns.is_empty() {
|
|
warn!(
|
|
columns = ?columns,
|
|
"Skipping instance group import from an unrecognized SQLite schema"
|
|
);
|
|
}
|
|
|
|
file.normalize();
|
|
Ok(file)
|
|
}
|
|
|
|
/// Creates `instance_groups.json` from the pre-existing SQLite tables and
|
|
/// instance sidecars, the first time the app runs after this change.
|
|
///
|
|
/// The SQL access here is read-only and happens exactly once; afterwards the
|
|
/// tables are never touched again (they are kept as-is so no DB migration is
|
|
/// needed).
|
|
pub async fn ensure_imported(state: &State) -> crate::Result<()> {
|
|
let Some(path) = file_path() else {
|
|
return Ok(());
|
|
};
|
|
if path.exists() {
|
|
// Populate the in-memory cache eagerly so the first synchronous read
|
|
// does not race with a write.
|
|
let _ = list();
|
|
return Ok(());
|
|
}
|
|
|
|
let file = import_sql_groups(&state.pool).await?;
|
|
let group_count = file.groups.len();
|
|
let instance_count = file.memberships.len();
|
|
|
|
// Seed the cache with the imported data instead of letting `store()` read
|
|
// the file we are about to write.
|
|
{
|
|
let lock = store();
|
|
let mut guard = lock.write().unwrap_or_else(|e| e.into_inner());
|
|
*guard = file;
|
|
write_to_disk(&guard);
|
|
}
|
|
|
|
info!(
|
|
"Imported {group_count} instance groups covering {instance_count} instances into {INSTANCE_GROUPS_FILE_NAME}"
|
|
);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use sqlx::sqlite::SqlitePoolOptions;
|
|
|
|
fn file_with_groups(ids: &[&str]) -> InstanceGroupsFile {
|
|
InstanceGroupsFile {
|
|
schema_version: INSTANCE_GROUPS_SCHEMA_VERSION,
|
|
groups: ids
|
|
.iter()
|
|
.map(|id| GroupDefinition {
|
|
id: id.to_string(),
|
|
name: id.to_string(),
|
|
})
|
|
.collect(),
|
|
memberships: HashMap::new(),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn normalize_inserts_favorites_first() {
|
|
let mut file = file_with_groups(&["a", "b"]);
|
|
file.normalize();
|
|
assert_eq!(file.groups[0].id, FAVORITES_GROUP_ID);
|
|
assert_eq!(file.groups.len(), 3);
|
|
}
|
|
|
|
#[test]
|
|
fn normalize_moves_favorites_to_front() {
|
|
let mut file = file_with_groups(&["a", FAVORITES_GROUP_ID, "b"]);
|
|
file.normalize();
|
|
assert_eq!(file.groups[0].id, FAVORITES_GROUP_ID);
|
|
assert_eq!(file.groups[1].id, "a");
|
|
assert_eq!(file.groups[2].id, "b");
|
|
}
|
|
|
|
#[test]
|
|
fn normalize_drops_orphan_memberships() {
|
|
let mut file = file_with_groups(&["a"]);
|
|
file.memberships.insert(
|
|
"instance".to_string(),
|
|
vec!["a".to_string(), "nonexistent".to_string()],
|
|
);
|
|
|
|
file.normalize();
|
|
assert_eq!(file.memberships["instance"], &["a"]);
|
|
}
|
|
|
|
#[test]
|
|
fn normalize_drops_memberships_for_nonexistent_instances() {
|
|
let mut file = file_with_groups(&["a"]);
|
|
file.memberships.insert(
|
|
"instance".to_string(),
|
|
vec!["nonexistent1".to_string(), "nonexistent2".to_string()],
|
|
);
|
|
file.normalize();
|
|
assert!(!file.memberships.contains_key("instance"));
|
|
}
|
|
|
|
fn group_ids(groups: &[GroupDefinition]) -> Vec<String> {
|
|
groups.iter().map(|group| group.id.clone()).collect()
|
|
}
|
|
|
|
#[test]
|
|
fn set_order_ignores_unknown_ids() {
|
|
let mut groups = file_with_groups(&["a", "b", "c"]).groups;
|
|
|
|
reorder_groups(&mut groups, &["unknown".to_string(), "c".to_string()]);
|
|
|
|
// The unknown id matches nothing and simply contributes no group.
|
|
assert_eq!(group_ids(&groups), vec!["c", "a", "b"]);
|
|
}
|
|
|
|
#[test]
|
|
fn set_order_retains_missing_groups_at_end() {
|
|
let mut groups = file_with_groups(&["a", "b", "c"]).groups;
|
|
groups.push(GroupDefinition {
|
|
id: "extra".to_string(),
|
|
name: "extra".to_string(),
|
|
});
|
|
|
|
reorder_groups(&mut groups, &["b".to_string()]);
|
|
|
|
// `b` moves to the front and every group the argument omitted survives
|
|
// after it, so a stale list can never drop a group. Favorites is pinned
|
|
// by `normalize`, which the store applies around this call.
|
|
assert_eq!(group_ids(&groups), vec!["b", "a", "c", "extra"]);
|
|
}
|
|
|
|
#[test]
|
|
fn set_order_keeps_favorites_out_of_the_reorder() {
|
|
let mut groups = file_with_groups(&["a", FAVORITES_GROUP_ID]).groups;
|
|
|
|
reorder_groups(&mut groups, &[FAVORITES_GROUP_ID.to_string()]);
|
|
|
|
// Favorites is skipped explicitly and survives at its previous position;
|
|
// `normalize` moves it to the front afterwards.
|
|
assert_eq!(group_ids(&groups), vec!["a", FAVORITES_GROUP_ID]);
|
|
}
|
|
|
|
#[test]
|
|
fn normalize_does_not_lose_favorites_membership() {
|
|
let mut file = file_with_groups(&[]);
|
|
file.memberships.insert(
|
|
"my_instance".to_string(),
|
|
vec![FAVORITES_GROUP_ID.to_string()],
|
|
);
|
|
file.normalize();
|
|
assert_eq!(file.memberships["my_instance"], &[FAVORITES_GROUP_ID]);
|
|
}
|
|
|
|
#[test]
|
|
fn normalize_deduplicates_group_ids() {
|
|
let mut file = file_with_groups(&["a", "b"]);
|
|
file.memberships.insert(
|
|
"instance".to_string(),
|
|
vec!["a".to_string(), "a".to_string(), "b".to_string()],
|
|
);
|
|
file.normalize();
|
|
assert_eq!(file.memberships["instance"].len(), 2);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn imports_legacy_instance_group_schema() {
|
|
let pool = SqlitePoolOptions::new()
|
|
.connect("sqlite::memory:")
|
|
.await
|
|
.unwrap();
|
|
sqlx::query(
|
|
"CREATE TABLE instance_groups (
|
|
instance_id TEXT NOT NULL,
|
|
group_name TEXT NOT NULL,
|
|
PRIMARY KEY (instance_id, group_name)
|
|
)",
|
|
)
|
|
.execute(&pool)
|
|
.await
|
|
.unwrap();
|
|
sqlx::query(
|
|
"INSERT INTO instance_groups (instance_id, group_name)
|
|
VALUES ('instance-1', 'Survival'), ('instance-2', 'Survival'),
|
|
('instance-1', 'Creative')",
|
|
)
|
|
.execute(&pool)
|
|
.await
|
|
.unwrap();
|
|
|
|
let file = import_sql_groups(&pool).await.unwrap();
|
|
|
|
assert_eq!(file.groups.len(), 3);
|
|
assert_eq!(file.groups[0].id, FAVORITES_GROUP_ID);
|
|
assert_eq!(file.memberships["instance-1"].len(), 2);
|
|
assert_eq!(file.memberships["instance-2"].len(), 1);
|
|
assert!(file.groups.iter().any(|group| group.name == "Survival"));
|
|
}
|
|
}
|