Fixed podcast sync

This commit is contained in:
ab committed 2026-11-22 17:11:37 +02:00
1 parent 441316f78f
commit 319f0bcba7
21 files changed
+1067 -276

No files matched your search

+14 -2
View File
@@ -31,8 +31,20 @@ its publications, clear saved audio, or delete the podcast for every user. Audio
retention is disabled by default. When enabled, its day count is measured from the
download time; the periodic job removes old audio while keeping episode descriptions
and listening progress. Removed audio is downloaded again only on an explicit save
or playback request. Podcast personal state is not replicated to trusted Frid devices
yet; device synchronization continues to advertise protocol v3.
or playback request.
Connected devices use Frid device-sync v4 to exchange podcast subscriptions, share
decisions, listening progress and listening-session records. Adding or removing a
subscription on one connected device updates the others; unsubscribe and share-off
registers survive offline devices reconnecting. Older v3 clients keep music sync and
receive no unsupported podcast operations or snapshot sections.
The main player search also finds accessible podcasts by words in their titles,
descriptions and authors. All query words must match; a private subscription is visible
only to its owner. Podcast search and the admin artist/release/track search use the
explicit ICU `und` collation `furumusic_unicode`, so case matching does not depend on
the database's initial locale (including databases created with the `C` locale).
PostgreSQL must include ICU support to apply migration `m_0055_podcast_sync_unicode_search`.
## Access and public sharing
+6
View File
@@ -62,10 +62,16 @@ retention and administrator actions:
```bash
node --test tests/podcasts.test.cjs
FURU_PODCAST_TEST_DATABASE_URL=postgresql://... cargo test podcasts -- --include-ignored
FURU_PODCAST_TEST_DATABASE_URL=postgresql://... cargo test admin_unicode_search -- --include-ignored
```
Use a disposable database. The PostgreSQL test creates and drops a unique schema;
its audio files use a unique temporary directory. Normal podcast tests need no network.
The podcast fixture includes real Frid v4 subscription operations, snapshot exchange,
offline unsubscribe replay, legacy-peer filtering, and private Unicode search. The
admin fixture exercises list counts, all three catalogue lists and the track picker
with Cyrillic and Greek searches. Use a PostgreSQL build with ICU support; running
these fixtures on a database created with locale `C` covers the locale regression.
The access regression suite uses a disposable migrated database and a local OIDC
provider with signed tokens and PKCE:
+105 -15
View File
@@ -3978,11 +3978,11 @@ async fn search_tracks(
LEFT JOIN furumusic__release r ON r.id = t.release_id \
LEFT JOIN furumusic__track_artist ta ON ta.track_id = t.id AND ta.role = 'main' \
LEFT JOIN furumusic__artist a ON a.id = ta.artist_id \
WHERE t.title ILIKE $1 OR COALESCE(r.title::text, '') ILIKE $1 OR COALESCE(a.name::text, '') ILIKE $1 \
WHERE t.title COLLATE furumusic_unicode ILIKE $1 OR COALESCE(r.title::text, '') COLLATE furumusic_unicode ILIKE $1 OR COALESCE(a.name::text, '') COLLATE furumusic_unicode ILIKE $1 \
GROUP BY t.id, r.id, r.title \
ORDER BY CASE \
WHEN LOWER(t.title::text) = LOWER($2) THEN 0 \
WHEN t.title ILIKE $3 THEN 1 \
WHEN LOWER(t.title::text COLLATE furumusic_unicode) = LOWER($2::text COLLATE furumusic_unicode) THEN 0 \
WHEN t.title COLLATE furumusic_unicode ILIKE $3 THEN 1 \
ELSE 2 \
END, \
t.title_sort ASC, t.id ASC \
@@ -4306,9 +4306,9 @@ fn push_library_search_filter(
};
match kind {
"releases" => {
qb.push(" AND (r.title ILIKE ");
qb.push(" AND (r.title COLLATE furumusic_unicode ILIKE ");
qb.push_bind(pattern.clone());
qb.push(" OR a.name ILIKE ");
qb.push(" OR a.name COLLATE furumusic_unicode ILIKE ");
qb.push_bind(pattern);
qb.push(")");
}
@@ -4322,16 +4322,16 @@ fn push_library_search_filter(
qb.push(")");
}
"tracks" => {
qb.push(" AND (t.title ILIKE ");
qb.push(" AND (t.title COLLATE furumusic_unicode ILIKE ");
qb.push_bind(pattern.clone());
qb.push(" OR r.title ILIKE ");
qb.push(" OR r.title COLLATE furumusic_unicode ILIKE ");
qb.push_bind(pattern.clone());
qb.push(" OR a.name ILIKE ");
qb.push(" OR a.name COLLATE furumusic_unicode ILIKE ");
qb.push_bind(pattern);
qb.push(")");
}
_ => {
qb.push(" AND a.name ILIKE ");
qb.push(" AND a.name COLLATE furumusic_unicode ILIKE ");
qb.push_bind(pattern);
}
}
@@ -4356,7 +4356,7 @@ async fn load_artist_items(
WHERE 1=1",
);
if let Some(pattern) = search_pattern {
qb.push(" AND a.name ILIKE ");
qb.push(" AND a.name COLLATE furumusic_unicode ILIKE ");
qb.push_bind(pattern);
}
qb.push(" GROUP BY a.id ORDER BY secondary_count DESC, a.name ASC LIMIT ");
@@ -4390,9 +4390,9 @@ async fn load_release_items(
WHERE 1=1",
);
if let Some(pattern) = search_pattern {
qb.push(" AND (r.title ILIKE ");
qb.push(" AND (r.title COLLATE furumusic_unicode ILIKE ");
qb.push_bind(pattern.clone());
qb.push(" OR a.name ILIKE ");
qb.push(" OR a.name COLLATE furumusic_unicode ILIKE ");
qb.push_bind(pattern);
qb.push(")");
}
@@ -4428,11 +4428,11 @@ async fn load_track_items(
WHERE 1=1",
);
if let Some(pattern) = search_pattern {
qb.push(" AND (t.title ILIKE ");
qb.push(" AND (t.title COLLATE furumusic_unicode ILIKE ");
qb.push_bind(pattern.clone());
qb.push(" OR r.title ILIKE ");
qb.push(" OR r.title COLLATE furumusic_unicode ILIKE ");
qb.push_bind(pattern.clone());
qb.push(" OR a.name ILIKE ");
qb.push(" OR a.name COLLATE furumusic_unicode ILIKE ");
qb.push_bind(pattern);
qb.push(")");
}
@@ -4612,6 +4612,96 @@ fn clean_search(search: Option<&str>) -> Option<String> {
.map(|s| s.chars().take(120).collect())
}
#[cfg(test)]
mod unicode_search_tests {
use super::*;
#[tokio::test]
#[ignore = "requires FURU_PODCAST_TEST_DATABASE_URL pointing to a disposable PostgreSQL database"]
async fn admin_unicode_search_matches_counts_lists_and_track_picker() {
let url = std::env::var("FURU_PODCAST_TEST_DATABASE_URL").unwrap();
let admin = PgPool::connect(&url).await.unwrap();
let schema = format!("unicode_search_{}", uuid::Uuid::new_v4().simple());
sqlx::query(&format!("CREATE SCHEMA {schema}"))
.execute(&admin)
.await
.unwrap();
let search_path = format!("SET search_path TO {schema}");
let pool = sqlx::postgres::PgPoolOptions::new()
.max_connections(2)
.after_connect(move |conn, _| {
let statement = search_path.clone();
Box::pin(async move {
sqlx::query(&statement).execute(conn).await?;
Ok(())
})
})
.connect(&url)
.await
.unwrap();
sqlx::query(
"CREATE COLLATION furumusic_unicode(provider=icu,locale='und',deterministic=true)",
)
.execute(&pool)
.await
.unwrap();
for statement in include_str!("../../tests/unicode_search_fixture.sql")
.split(';')
.filter(|s| !s.trim().is_empty())
{
sqlx::query(statement).execute(&pool).await.unwrap();
}
for query in ["АЛИСА", "алиса", "АлИсА"] {
let pattern = Some(format!("%{query}%"));
for kind in ["artists", "releases", "tracks"] {
assert_eq!(
count_library(&pool, kind, pattern.clone()).await.unwrap(),
1,
"{kind}: {query}"
);
}
assert_eq!(
load_artist_items(&pool, pattern.clone(), 10, 0)
.await
.unwrap()
.len(),
1
);
assert_eq!(
load_release_items(&pool, pattern.clone(), 10, 0)
.await
.unwrap()
.len(),
1
);
assert_eq!(
load_track_items(&pool, pattern, 10, 0).await.unwrap().len(),
1
);
}
for query in ["солнце", "СОЛНЦЕ", "ελληνικά", "ΕΛΛΗΝΙΚΆ", "трек", "ТРЕК"]
{
assert_eq!(
load_track_items(&pool, Some(format!("%{query}%")), 10, 0)
.await
.unwrap()
.len(),
1,
"{query}"
);
assert_eq!(
search_tracks(&pool, query, 10).await.unwrap().len(),
1,
"picker: {query}"
);
}
pool.close().await;
sqlx::query(&format!("DROP SCHEMA {schema} CASCADE"))
.execute(&admin)
.await
.unwrap();
}
}
fn normalize_name(value: &str) -> String {
value.trim().to_lowercase()
}
+1 -1
View File
@@ -15,7 +15,7 @@ fn local_manifest() -> CapabilityManifest {
CapabilityManifest::frid("furumusic", env!("CARGO_PKG_VERSION"))
// The web server does not expose federation Jam yet.
.without_protocol(JAM_ID)
// Podcast discovery is supported, but personal device sync remains v3.
// Keep the advertised version aligned with the web device-sync adapter.
.with_protocol(DEVICE_SYNC_ID, super::devices::PROTOCOL_VERSION)
.with_protocol("audio", AUDIO_PROTOCOL_VERSION)
.with_protocol(
+167 -230
View File
@@ -5,9 +5,7 @@
//! protocol as the TUI clients on `furumi/sync/1` and maps operations into
//! user-scoped Postgres state.
use music_dht::playback::{
Announcement, Checkpoint, CommandStamp, Config as PlaybackConfig, Engine,
};
use music_dht::playback::{Announcement, Checkpoint, Config as PlaybackConfig, Engine};
use std::collections::BTreeMap;
use std::str::FromStr;
use std::sync::Arc;
@@ -27,7 +25,7 @@ use super::{TransportStats, record_stream_transport};
pub const SYNC_ALPN: &[u8] = b"furumi/sync/2";
const CLIENT_VERSION: &str = env!("CARGO_PKG_VERSION");
pub(super) const PROTOCOL_VERSION: u16 = 3;
pub(super) const PROTOCOL_VERSION: u16 = 4;
const INVITE_TTL_MS: i64 = 10 * 60 * 1000;
const PAIRING_WAIT_MS: i64 = 5 * 60 * 1000;
const PAIRING_RETRY_DELAY: Duration = Duration::from_secs(1);
@@ -125,220 +123,12 @@ struct DeviceProfileWire {
updated_at_ms: i64,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
struct SyncedFedTrack {
item_id: String,
owner: String,
title: String,
#[serde(default)]
artist_names: Vec<String>,
#[serde(default)]
featured_artist_names: Vec<String>,
year: Option<i32>,
duration_seconds: Option<i64>,
content_id: String,
release_title: Option<String>,
track_number: Option<i32>,
disc_number: Option<i32>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
struct PlaybackTrack {
id: i64,
title: String,
track_number: Option<i32>,
disc_number: Option<i32>,
duration_seconds: f64,
#[serde(default)]
artist_names: Vec<String>,
#[serde(default)]
featured_artist_names: Vec<String>,
release_id: i64,
release_title: String,
release_year: Option<i32>,
#[serde(default)]
file_path: String,
content_id: Option<String>,
audio_format: Option<String>,
audio_bitrate: Option<i32>,
audio_sample_rate: Option<i32>,
audio_bit_depth: Option<i32>,
file_size_bytes: Option<i64>,
#[serde(default)]
play_count: i64,
#[serde(default)]
fed: Option<SyncedFedTrack>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
enum PlaybackRepeat {
#[default]
Off,
One,
All,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
struct PlaybackStateWire {
#[serde(default)]
queue: Vec<PlaybackTrack>,
#[serde(default)]
queue_pos: usize,
playing: bool,
paused: bool,
#[serde(default)]
idle_since_ms: Option<i64>,
position_secs: f64,
#[serde(default)]
volume: u8,
shuffle: bool,
repeat: PlaybackRepeat,
}
type PlaybackSnapshot = music_dht::playback::Snapshot<PlaybackStateWire>;
type PlaybackCommand = music_dht::playback::Command<PlaybackStateWire>;
#[derive(Debug, Clone, Serialize, Deserialize)]
struct SyncOpWire {
op_id: String,
origin_device_id: String,
seq: i64,
hlc_ms: i64,
payload: SyncOpPayload,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case")]
enum SyncOpPayload {
TrackLikeSet {
content_id: String,
liked: bool,
#[serde(default)]
fed: Option<SyncedFedTrack>,
},
PlaylistCreated {
playlist_id: String,
title: String,
},
PlaylistRenamed {
playlist_id: String,
title: String,
},
PlaylistDeleted {
playlist_id: String,
},
PlaylistTrackAdded {
playlist_id: String,
content_id: String,
position: i64,
#[serde(default)]
fed: Option<SyncedFedTrack>,
},
PlaylistTrackRemoved {
playlist_id: String,
content_id: String,
},
DeviceProfileSet {
name: String,
client_version: String,
endpoint_ticket: String,
endpoint_id: String,
},
DeviceTrusted {
target_device_id: String,
},
DeviceRevoked {
target_device_id: String,
target_max_seq_seen: i64,
},
PlaybackCommand {
target_device_id: String,
command: PlaybackCommand,
#[serde(default)]
authority: Option<CommandStamp>,
},
ListenRecorded {
event: ListenEvent,
},
}
impl SyncOpPayload {
fn is_tombstone(&self) -> bool {
matches!(
self,
SyncOpPayload::TrackLikeSet { liked: false, .. }
| SyncOpPayload::PlaylistDeleted { .. }
| SyncOpPayload::PlaylistTrackRemoved { .. }
| SyncOpPayload::DeviceRevoked { .. }
)
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
struct SyncSnapshot {
#[serde(default)]
likes: Vec<SnapshotLike>,
#[serde(default)]
unlikes: Vec<SnapshotLikeTombstone>,
#[serde(default)]
playlists: Vec<SnapshotPlaylist>,
#[serde(default)]
deleted_playlists: Vec<SnapshotPlaylistTombstone>,
#[serde(default)]
removed_playlist_items: Vec<SnapshotPlaylistItemTombstone>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
struct SnapshotLike {
content_id: String,
hlc_ms: i64,
op_id: String,
#[serde(default)]
fed: Option<SyncedFedTrack>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
struct SnapshotLikeTombstone {
content_id: String,
hlc_ms: i64,
op_id: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
struct SnapshotPlaylist {
playlist_id: String,
title: String,
hlc_ms: i64,
op_id: String,
#[serde(default)]
items: Vec<SnapshotPlaylistItem>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
struct SnapshotPlaylistTombstone {
playlist_id: String,
hlc_ms: i64,
op_id: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
struct SnapshotPlaylistItem {
content_id: String,
position: i64,
hlc_ms: i64,
op_id: String,
#[serde(default)]
fed: Option<SyncedFedTrack>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
struct SnapshotPlaylistItemTombstone {
playlist_id: String,
content_id: String,
hlc_ms: i64,
op_id: String,
}
use music_dht::device_sync::{
PlaybackCommand, PlaybackRepeat, PlaybackSnapshot, PlaybackStateWire, PlaybackTrack,
SnapshotLike, SnapshotLikeTombstone, SnapshotPlaylist, SnapshotPlaylistItem,
SnapshotPlaylistItemTombstone, SnapshotPlaylistTombstone, SyncOpPayload, SyncOpWire,
SyncSnapshot, SyncedFedTrack,
};
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
@@ -1180,8 +970,9 @@ async fn try_connect_invite(
let devices = device_profiles(pool, user_id).await?;
let vector = vector(pool, user_id).await?;
let ops = ops_for_peer(pool, user_id, &invite.device_id).await?;
let snapshot = snapshot(pool, user_id).await?;
let snapshot = snapshot_for_peer(pool, user_id, &invite.device_id).await?;
let playback = local_playback_snapshot(pool, Arc::clone(&hub), user_id, &identity).await;
let playback = playback_for_peer(pool, user_id, &invite.device_id, playback).await?;
let mut stream = service.open_stream(peer, SYNC_ALPN).await?;
record_stream_transport(&transport_stats, "device-sync", "outbound", "open", &stream);
write_msg(
@@ -1235,6 +1026,7 @@ async fn try_connect_invite(
apply_device_profiles(pool, user_id, &devices).await?;
apply_snapshot(pool, user_id, snapshot).await?;
apply_ops(pool, Arc::clone(&hub), user_id, ops).await?;
crate::podcasts::sync::exchange_complete(pool, user_id, &invite.device_id).await?;
record_local_op(
pool,
user_id,
@@ -1459,6 +1251,7 @@ async fn handle_pair_request(
}
apply_snapshot(pool, user_id, incoming_snapshot).await?;
apply_ops(pool, Arc::clone(&hub), user_id, ops).await?;
crate::podcasts::sync::exchange_complete(pool, user_id, &profile.device_id).await?;
apply_device_profiles(pool, user_id, &requester_group_devices).await?;
note_peer_vector(pool, user_id, &profile.device_id, &incoming_vector).await?;
sqlx::query("UPDATE furumusic__fed_device_invite SET used_at_ms = $2 WHERE invite_id = $1")
@@ -1476,8 +1269,9 @@ async fn handle_pair_request(
let devices = device_profiles(pool, user_id).await?;
let vector = vector(pool, user_id).await?;
let ops = ops_for_peer(pool, user_id, &profile.device_id).await?;
let snapshot = snapshot(pool, user_id).await?;
let snapshot = snapshot_for_peer(pool, user_id, &profile.device_id).await?;
let playback = local_playback_snapshot(pool, hub, user_id, &identity).await;
let playback = playback_for_peer(pool, user_id, &profile.device_id, playback).await?;
write_msg(
&mut stream,
&WireMessage::PairResponse {
@@ -1522,8 +1316,9 @@ async fn handle_hello(
return write_sync_reject(stream, "sync group mismatch").await;
}
profile.endpoint_id = stream.peer_id.to_string();
apply_device_profile(pool, user_id, &profile, false).await?;
apply_device_profiles(pool, user_id, &devices).await?;
// A sender's own current report takes precedence over relayed profiles.
apply_device_profile(pool, user_id, &profile, false).await?;
if let Some(playback) = playback {
apply_playback_snapshot(
Arc::clone(&hub),
@@ -1536,6 +1331,7 @@ async fn handle_hello(
}
apply_snapshot(pool, user_id, incoming_snapshot).await?;
apply_ops(pool, Arc::clone(&hub), user_id, ops).await?;
crate::podcasts::sync::exchange_complete(pool, user_id, &profile.device_id).await?;
note_peer_vector(pool, user_id, &profile.device_id, &incoming_vector).await?;
mark_seen(
pool,
@@ -1557,8 +1353,9 @@ async fn handle_hello(
devices.push(own_profile);
let vector = vector(pool, user_id).await?;
let ops = ops_for_peer(pool, user_id, &profile.device_id).await?;
let snapshot = snapshot(pool, user_id).await?;
let snapshot = snapshot_for_peer(pool, user_id, &profile.device_id).await?;
let playback = local_playback_snapshot(pool, hub, user_id, &identity).await;
let playback = playback_for_peer(pool, user_id, &profile.device_id, playback).await?;
write_msg(
&mut stream,
&WireMessage::SyncResponse {
@@ -1592,8 +1389,9 @@ async fn sync_device(
let devices = device_profiles(pool, user_id).await?;
let vector = vector(pool, user_id).await?;
let ops = ops_for_peer(pool, user_id, &device.device_id).await?;
let snapshot = snapshot(pool, user_id).await?;
let snapshot = snapshot_for_peer(pool, user_id, &device.device_id).await?;
let playback = local_playback_snapshot(pool, Arc::clone(&hub), user_id, &identity).await;
let playback = playback_for_peer(pool, user_id, &device.device_id, playback).await?;
let mut stream = service.open_stream(peer, SYNC_ALPN).await?;
record_stream_transport(&transport_stats, "device-sync", "outbound", "open", &stream);
write_msg(
@@ -1637,6 +1435,7 @@ async fn sync_device(
}
apply_snapshot(pool, user_id, snapshot).await?;
apply_ops(pool, hub, user_id, ops).await?;
crate::podcasts::sync::exchange_complete(pool, user_id, &device.device_id).await?;
note_peer_vector(pool, user_id, &device.device_id, &vector).await?;
mark_seen(
pool,
@@ -2049,6 +1848,34 @@ async fn record_local_op(
Ok(())
}
pub(crate) async fn record_podcast_op(
pool: &sqlx::PgPool,
user_id: i64,
payload: SyncOpPayload,
) -> Result<()> {
let identity = ensure_identity(pool, user_id, "").await?;
let mut tx = pool.begin().await?;
sqlx::query("SELECT pg_advisory_xact_lock(hashtextextended($1,7512))")
.bind(format!("podcast-sync:{user_id}"))
.execute(&mut *tx)
.await?;
let row=sqlx::query("UPDATE furumusic__fed_device_identity SET local_seq=local_seq+1,last_hlc_ms=GREATEST($2,last_hlc_ms+1) WHERE user_id=$1 RETURNING local_seq,last_hlc_ms").bind(user_id).bind(now_ms()).fetch_one(&mut *tx).await?;
let seq: i64 = row.get("local_seq");
let op = SyncOpWire {
op_id: format!("{}:{seq}", identity.device_id),
origin_device_id: identity.device_id,
seq,
hlc_ms: row.get("last_hlc_ms"),
payload,
};
op.validate_podcast()?;
sqlx::query("INSERT INTO furumusic__fed_sync_ops(user_id,op_id,origin_device_id,seq,kind,payload_json,hlc_ms,received_at_ms,tombstone) VALUES($1,$2,$3,$4,$5,$6,$7,$8,false)").bind(user_id).bind(&op.op_id).bind(&op.origin_device_id).bind(seq).bind(payload_kind(&op.payload)).bind(serde_json::to_value(&op.payload)?).bind(op.hlc_ms).bind(now_ms()).execute(&mut *tx).await?;
sqlx::query("INSERT INTO furumusic__fed_sync_vector(user_id,device_id,max_seq) VALUES($1,$2,$3) ON CONFLICT(user_id,device_id) DO UPDATE SET max_seq=GREATEST(furumusic__fed_sync_vector.max_seq,EXCLUDED.max_seq)").bind(user_id).bind(&op.origin_device_id).bind(seq).execute(&mut *tx).await?;
crate::podcasts::sync::apply_op_tx(&mut tx, user_id, &op).await?;
tx.commit().await?;
Ok(())
}
async fn apply_ops(
pool: &sqlx::PgPool,
hub: Arc<PlayerDeviceHub>,
@@ -2078,7 +1905,7 @@ async fn apply_ops(
.execute(pool)
.await?
.rows_affected();
if inserted > 0 {
if inserted > 0 || op.payload.is_podcast() {
let _ = apply_op(pool, Arc::clone(&hub), user_id, &op).await?;
}
sqlx::query(
@@ -2127,6 +1954,9 @@ async fn apply_op(
user_id: i64,
op: &SyncOpWire,
) -> Result<bool> {
if op.payload.is_podcast() {
return crate::podcasts::sync::apply_op(pool, user_id, op).await;
}
match &op.payload {
SyncOpPayload::TrackLikeSet {
content_id,
@@ -2201,12 +2031,16 @@ async fn apply_op(
client_version,
endpoint_ticket,
endpoint_id,
protocol_version,
} => {
let profile = DeviceProfileWire {
device_id: op.origin_device_id.clone(),
name: name.clone(),
client_version: client_version.clone(),
protocol_version: PROTOCOL_VERSION,
protocol_version: music_dht::device_sync::profile_protocol_version(
*protocol_version,
Some(peer_protocol_version(pool, user_id, &op.origin_device_id).await?),
),
endpoint_id: endpoint_id.clone(),
endpoint_ticket: endpoint_ticket.clone(),
revoked: false,
@@ -2240,6 +2074,7 @@ async fn apply_op(
SyncOpPayload::ListenRecorded { event } => {
apply_listen_event(pool, user_id, &op.origin_device_id, event).await
}
_ => Ok(false),
}
}
@@ -2605,6 +2440,8 @@ async fn apply_playlist_item_state(
}
async fn apply_snapshot(pool: &sqlx::PgPool, user_id: i64, snapshot: SyncSnapshot) -> Result<()> {
crate::podcasts::sync::apply_snapshot(pool, user_id, &snapshot).await?;
crate::podcasts::sync::refresh_received(pool.clone());
for like in snapshot.likes {
apply_like_state(
pool,
@@ -2690,7 +2527,12 @@ async fn apply_device_profiles(
devices: &[DeviceProfileWire],
) -> Result<()> {
for profile in devices {
apply_device_profile(pool, user_id, profile, false).await?;
let mut relayed = profile.clone();
relayed.protocol_version = music_dht::device_sync::relayed_protocol_version(
profile.protocol_version,
Some(peer_protocol_version(pool, user_id, &profile.device_id).await?),
);
apply_device_profile(pool, user_id, &relayed, false).await?;
}
Ok(())
}
@@ -2846,6 +2688,14 @@ async fn apply_playback_command(
};
let authority = authority.as_ref();
let origin = &op.origin_device_id;
if peer_protocol_version(pool, user_id, origin).await? < 4
&& let Some(state) = hub.playback_state_json_for_commands(user_id)
{
let local = playback_state_from_browser_json(pool, state).await?;
if !music_dht::device_sync::playback_command_allowed_from_peer(&local, 3) {
return Ok(());
}
}
let op_id = &op.op_id;
let identity = ensure_identity(pool, user_id, "").await?;
let Some(authority) = authority else {
@@ -3009,6 +2859,7 @@ pub async fn record_web_playback_command(
ensure_web_playback_target(pool, user_id, target_device_id).await?;
let next_state = browser_state_for_command(command, payload, current_state)?;
let wire = playback_state_from_browser_json(pool, next_state.clone()).await?;
require_playback_peer(pool, user_id, target_device_id, &wire).await?;
record_local_op(
pool,
user_id,
@@ -3037,6 +2888,7 @@ pub async fn record_web_active_transfer(
) -> Result<()> {
ensure_web_playback_target(pool, user_id, target_device_id).await?;
let wire = playback_state_from_browser_json(pool, state).await?;
require_playback_peer(pool, user_id, target_device_id, &wire).await?;
let target_name = web_playback_target_name(pool, user_id, target_device_id).await?;
let identity = ensure_identity(pool, user_id, "").await?;
with_playback_engine(pool, user_id, &identity, |engine| {
@@ -3710,6 +3562,7 @@ async fn playback_state_from_browser_json(
}
}
Ok(PlaybackStateWire {
playback_rate: Some(1.0),
queue,
queue_pos: state
.get("index")
@@ -3754,6 +3607,20 @@ async fn playback_track_from_track_json(
track_id: i64,
track: &serde_json::Value,
) -> Result<PlaybackTrack> {
if let Some(source) = track.get("podcast_source") {
let source: music_dht::device_sync::PlaybackSource =
serde_json::from_value(source.clone())?;
match source {
music_dht::device_sync::PlaybackSource::PodcastEpisode(episode) => {
episode.validate()?;
return Ok(PlaybackTrack::podcast_episode(*episode));
}
music_dht::device_sync::PlaybackSource::Private => {
return Ok(PlaybackTrack::private_placeholder());
}
music_dht::device_sync::PlaybackSource::Music => {}
}
}
Ok(PlaybackTrack {
id: track_id,
title: track
@@ -3819,6 +3686,7 @@ async fn playback_track_from_track_json(
.and_then(serde_json::Value::as_i64),
play_count: 0,
fed: None,
source: None,
})
}
@@ -3842,6 +3710,12 @@ async fn resolve_playback_tracks(
) -> Result<Vec<serde_json::Value>> {
let mut out = Vec::new();
for (index, track) in tracks.iter().enumerate() {
if track.requires_podcast_support() {
let mut value = placeholder_playback_track(track, index, None);
value["podcast_source"] = serde_json::to_value(&track.source)?;
out.push(value);
continue;
}
let content_id = track
.content_id
.as_deref()
@@ -4476,6 +4350,7 @@ async fn ops_for_peer(
user_id: i64,
peer_device_id: &str,
) -> Result<Vec<SyncOpWire>> {
let peer_version = peer_protocol_version(pool, user_id, peer_device_id).await?;
let rows = sqlx::query(
"SELECT o.op_id, o.origin_device_id, o.seq, o.hlc_ms, o.payload_json
FROM furumusic__fed_sync_ops o
@@ -4485,6 +4360,7 @@ async fn ops_for_peer(
AND a.origin_device_id = o.origin_device_id
WHERE o.user_id = $1
AND o.seq > COALESCE(a.max_seq, 0)
AND ($5 >= 4 OR o.kind NOT LIKE 'podcast_%')
AND (
o.kind != 'playback_command'
OR (
@@ -4499,9 +4375,11 @@ async fn ops_for_peer(
.bind(peer_device_id)
.bind(now_ms().saturating_sub(PLAYBACK_COMMAND_TTL_MS))
.bind(MAX_OPS_PER_BATCH)
.bind(peer_version as i32)
.fetch_all(pool)
.await?;
rows.into_iter()
let ops: Vec<SyncOpWire> = rows
.into_iter()
.map(|row| {
let payload_json: serde_json::Value = row.get("payload_json");
Ok(SyncOpWire {
@@ -4512,7 +4390,58 @@ async fn ops_for_peer(
payload: serde_json::from_value(payload_json)?,
})
})
.collect()
.collect::<Result<Vec<_>>>()?;
Ok(ops
.into_iter()
.filter(|op| music_dht::device_sync::op_allowed_for_peer(&op.payload, peer_version))
.collect())
}
async fn peer_protocol_version(pool: &sqlx::PgPool, user_id: i64, device_id: &str) -> Result<u16> {
let version: Option<i32> = sqlx::query_scalar(
"SELECT protocol_version FROM furumusic__fed_device WHERE user_id=$1 AND device_id=$2",
)
.bind(user_id)
.bind(device_id)
.fetch_optional(pool)
.await?;
Ok(version.unwrap_or(3) as u16)
}
async fn snapshot_for_peer(
pool: &sqlx::PgPool,
user_id: i64,
device_id: &str,
) -> Result<SyncSnapshot> {
Ok(snapshot(pool, user_id)
.await?
.for_peer(peer_protocol_version(pool, user_id, device_id).await?))
}
async fn playback_for_peer(
pool: &sqlx::PgPool,
user_id: i64,
device_id: &str,
playback: Option<PlaybackSnapshot>,
) -> Result<Option<PlaybackSnapshot>> {
let version = peer_protocol_version(pool, user_id, device_id).await?;
Ok(playback.filter(|snapshot| {
music_dht::device_sync::playback_allowed_for_peer(&snapshot.state, version)
}))
}
async fn require_playback_peer(
pool: &sqlx::PgPool,
user_id: i64,
device_id: &str,
state: &PlaybackStateWire,
) -> Result<()> {
if !music_dht::device_sync::playback_allowed_for_peer(
state,
peer_protocol_version(pool, user_id, device_id).await?,
) {
anyhow::bail!("update the connected player to play podcast queues");
}
Ok(())
}
async fn snapshot(pool: &sqlx::PgPool, user_id: i64) -> Result<SyncSnapshot> {
@@ -4601,13 +4530,16 @@ async fn snapshot(pool: &sqlx::PgPool, user_id: i64) -> Result<SyncSnapshot> {
op_id: row.get("op_id"),
})
.collect();
Ok(SyncSnapshot {
let mut result = SyncSnapshot {
likes,
unlikes,
playlists,
deleted_playlists,
removed_playlist_items,
})
..SyncSnapshot::default()
};
crate::podcasts::sync::append_snapshot(pool, user_id, &mut result).await?;
Ok(result)
}
async fn snapshot_playlist_items(
@@ -4852,6 +4784,11 @@ fn payload_kind(payload: &SyncOpPayload) -> &'static str {
SyncOpPayload::DeviceRevoked { .. } => "device_revoked",
SyncOpPayload::PlaybackCommand { .. } => "playback_command",
SyncOpPayload::ListenRecorded { .. } => "listen_recorded",
SyncOpPayload::PodcastSubscriptionSet { .. } => "podcast_subscription_set",
SyncOpPayload::PodcastShareSet { .. } => "podcast_share_set",
SyncOpPayload::PodcastFeedAliasesAdded { .. } => "podcast_feed_aliases_added",
SyncOpPayload::PodcastProgressSet { .. } => "podcast_progress_set",
SyncOpPayload::PodcastListenRecorded { .. } => "podcast_listen_recorded",
}
}
+1 -1
View File
@@ -305,7 +305,7 @@ translations! {
player_likes_count: "likes" , "лайков";
player_likes_playlist: "Likes" , "Лайки";
player_listened: "listened" , "прослушано";
player_search_placeholder: "Search artists, releases, tracks..." , "Поиск артистов, релизов, треков...";
player_search_placeholder: "Search artists, releases, tracks, podcasts..." , "Поиск артистов, релизов, треков, подкастов...";
player_search_similar_to: "Search similar to:" , "Поиск похожих на:";
player_find_similar: "Find similar tracks" , "Найти похожие треки";
player_similarity_failed: "Similarity search failed" , "Не удалось найти похожие треки";
+23
View File
@@ -2865,6 +2865,28 @@ pub mod db_migrations {
const OPERATIONS: &'static [Operation] = &[Operation::custom(create_podcasts).build()];
}
#[cot::db::migrations::migration_op]
async fn create_podcast_sync(ctx: migrations::MigrationContext<'_>) -> cot::db::Result<()> {
for statement in include_str!("../podcasts/sync_schema.sql").split(';') {
if !statement.trim().is_empty() {
ctx.db.raw(statement).await?;
}
}
Ok(())
}
#[derive(Debug, Copy, Clone)]
pub struct M0055PodcastSyncAndUnicodeSearch;
impl migrations::Migration for M0055PodcastSyncAndUnicodeSearch {
const APP_NAME: &'static str = "furumusic";
const MIGRATION_NAME: &'static str = "m_0055_podcast_sync_unicode_search";
const DEPENDENCIES: &'static [migrations::MigrationDependency] =
&[migrations::MigrationDependency::migration(
"furumusic",
"m_0054_create_podcasts",
)];
const OPERATIONS: &'static [Operation] = &[Operation::custom(create_podcast_sync).build()];
}
pub const MIGRATIONS: &[&SyncDynMigration] = &[
&M0006CreateMediaFile,
&M0007CreateArtist,
@@ -2909,5 +2931,6 @@ pub mod db_migrations {
&M0051AddListenStatisticsIndexes,
&M0052AddImportPlaylistDestinations,
&M0054CreatePodcasts,
&M0055PodcastSyncAndUnicodeSearch,
];
}
+1
View File
@@ -332,6 +332,7 @@ pub(super) struct ShareDetail {
#[derive(Debug, Serialize, JsonSchema)]
pub(super) struct SearchResults {
pub(super) podcasts: Vec<serde_json::Value>,
pub(super) artists: Vec<ArtistCard>,
pub(super) releases: Vec<ReleaseCard>,
pub(super) tracks: Vec<TrackItem>,
+27 -2
View File
@@ -1046,7 +1046,18 @@ impl PlayerDeviceHub {
.playback_state_by_user
.get(&playback_user_id)
.cloned()
.map(|playback_state| playback_state_at(playback_state, now))
.map(|playback_state| {
let mut playback_state = playback_state_at(playback_state, now);
if playback_user_id != user_id {
for track in &mut playback_state.tracks {
redact_podcast_track(track);
}
if let Some(track) = &mut playback_state.track {
redact_podcast_track(track);
}
}
playback_state
})
}
fn jam_dtos_locked(
@@ -1150,6 +1161,16 @@ fn current_millis() -> i64 {
chrono::Utc::now().timestamp_millis()
}
fn redact_podcast_track(track: &mut serde_json::Value) {
if track.get("podcast_source").is_none()
&& track.get("podcast").and_then(serde_json::Value::as_bool) != Some(true)
{
return;
}
let id = track.get("id").cloned().unwrap_or(serde_json::json!(0));
*track = serde_json::json!({"id":id,"title":"Private item","artists":[],"featured_artists":[],"release_id":0,"release_title":"","cover_url":null,"stream_url":"","duration_seconds":0,"unavailable":true,"podcast_source":{"kind":"private"}});
}
fn fed_virtual_device_id(device_id: &str) -> String {
format!("{FED_DEVICE_PREFIX}{device_id}")
}
@@ -6657,13 +6678,14 @@ async fn search_handler(
pool: &sqlx::PgPool,
query: cot::request::extractors::UrlQuery<SearchQuery>,
) -> cot::Result<cot::response::Response> {
let Some(_user) = auth::get_request_user(&auth_ctx, &session, &db).await else {
let Some(user) = auth::get_request_user(&auth_ctx, &session, &db).await else {
return Ok(json_error(StatusCode::UNAUTHORIZED, "not authenticated"));
};
let q = query.0.q.trim().to_lowercase();
if q.is_empty() {
return Json(SearchResults {
podcasts: Vec::new(),
artists: Vec::new(),
releases: Vec::new(),
tracks: Vec::new(),
@@ -6968,6 +6990,9 @@ async fn search_handler(
.collect();
Json(SearchResults {
podcasts: crate::podcasts::search(pool, user.id, &q, limit)
.await
.map_err(|e| cot::Error::internal(e.to_string()))?,
artists,
releases,
tracks,
+30 -1
View File
@@ -1,4 +1,5 @@
//! Server-owned podcast catalogue and cache; subscriptions and progress are personal.
pub(crate) mod sync;
mod web;
pub use web::PodcastApp;
@@ -21,6 +22,30 @@ use tokio::io::AsyncWriteExt;
const MAX_FEED_BYTES: usize = 16 * 1024 * 1024;
const MAX_AUDIO_BYTES: u64 = 2 * 1024 * 1024 * 1024;
pub(crate) async fn search(
pool: &PgPool,
user: i64,
query: &str,
limit: i64,
) -> Result<Vec<Value>> {
let words: Vec<String> = query
.split_whitespace()
.take(20)
.map(|word| {
format!(
"%{}%",
word.replace('\\', "\\\\")
.replace('%', "\\%")
.replace('_', "\\_")
)
})
.collect();
if words.is_empty() {
return Ok(Vec::new());
}
Ok(sqlx::query_scalar("SELECT jsonb_build_object('id',p.id,'url',p.origin_url,'metadata',p.metadata,'subscribed',EXISTS(SELECT 1 FROM furumusic__podcast_subscription s WHERE s.user_id=$1 AND s.podcast_id=p.id)) FROM furumusic__podcast p WHERE EXISTS(SELECT 1 FROM furumusic__podcast_subscription s WHERE s.podcast_id=p.id AND (s.user_id=$1 OR s.shared)) AND NOT EXISTS(SELECT 1 FROM unnest($2::text[]) AS term WHERE concat_ws(' ',p.metadata->>'title',p.metadata->>'description',p.metadata->>'author') COLLATE furumusic_unicode NOT ILIKE term) ORDER BY p.metadata->>'title',p.id LIMIT $3").bind(user).bind(words).bind(limit.clamp(1,100)).fetch_all(pool).await?)
}
fn public_address(ip: IpAddr) -> bool {
match ip {
IpAddr::V4(ip) => {
@@ -244,6 +269,7 @@ async fn refresh_inner(pool: &PgPool, id: &str) -> Result<usize> {
let meta = episode.to_meta(&podcast_id, episode_id.clone());
let inserted: bool = sqlx::query_scalar("INSERT INTO furumusic__podcast_episode(id,podcast_id,metadata) VALUES($1,$2,$3) ON CONFLICT(id) DO UPDATE SET metadata=EXCLUDED.metadata RETURNING (xmax=0)").bind(episode_id.as_str()).bind(id).bind(serde_json::to_value(meta)?).fetch_one(&mut *tx).await?;
added += usize::from(inserted);
sync::restore_episode_progress(&mut tx, episode_id.as_str()).await?;
}
for alias in [
Some(final_url.clone()),
@@ -342,9 +368,12 @@ pub async fn reconcile(pool: &PgPool, overlay: &PodcastDht) -> Result<()> {
// never publish its snapshot after a completed share-off/unsubscribe pass.
static GATE: tokio::sync::Mutex<()> = tokio::sync::Mutex::const_new(());
let _guard = GATE.lock().await;
let rows = sqlx::query("SELECT p.*,s.confirmed_urls FROM furumusic__podcast p JOIN furumusic__podcast_subscription s ON s.podcast_id=p.id WHERE s.shared ORDER BY p.id").fetch_all(pool).await?;
let rows = sqlx::query("SELECT p.*,s.confirmed_urls,s.user_id FROM furumusic__podcast p JOIN furumusic__podcast_subscription s ON s.podcast_id=p.id WHERE s.shared ORDER BY p.id").fetch_all(pool).await?;
let mut states = std::collections::BTreeMap::new();
for row in rows {
if !sync::publication_current(pool, row.get("user_id")).await? {
continue;
}
let id: String = row.get("id");
let meta: PodcastMeta = serde_json::from_value(row.get("metadata"))?;
let origin = FeedUrl::parse(row.get::<&str, _>("origin_url"))?;
+448
View File
@@ -0,0 +1,448 @@
//! Durable Frid podcast registers. Projections are user-scoped; revocations
//! remain here after a subscription is removed from the visible catalogue.
use super::*;
use music_dht::device_sync::{SyncOpPayload, SyncOpWire, SyncSnapshot};
use music_dht::podcast::{
ListenSession, ProgressRecord, ProgressStatus, effective_share, merge_listen_session,
merge_progress, merge_share, merge_subscription, next_podcast_generation,
};
use serde::{Serialize, de::DeserializeOwned};
use sqlx::{Postgres, Transaction};
fn current_users() -> &'static std::sync::Mutex<std::collections::HashSet<i64>> {
static USERS: std::sync::OnceLock<std::sync::Mutex<std::collections::HashSet<i64>>> =
std::sync::OnceLock::new();
USERS.get_or_init(Default::default)
}
pub async fn publication_current(pool: &PgPool, user: i64) -> Result<bool> {
if current_users()
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.contains(&user)
{
return Ok(true);
}
let peers:bool=sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM furumusic__fed_device d WHERE user_id=$1 AND trusted_at_ms IS NOT NULL AND revoked_at_ms IS NULL AND protocol_version>=4 AND device_id<>(SELECT device_id FROM furumusic__fed_device_identity WHERE user_id=$1))").bind(user).fetch_one(pool).await?;
Ok(!peers)
}
pub async fn exchange_complete(pool: &PgPool, user: i64, peer: &str) -> Result<()> {
let version: Option<i32> = sqlx::query_scalar(
"SELECT protocol_version FROM furumusic__fed_device WHERE user_id=$1 AND device_id=$2",
)
.bind(user)
.bind(peer)
.fetch_optional(pool)
.await?;
if version.is_some_and(|v| v >= 4) {
current_users()
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.insert(user);
refresh_received(pool.clone());
tokio::spawn(async {
let _ = crate::federation::handle().sync_podcasts().await;
});
}
Ok(())
}
async fn get<T: DeserializeOwned>(
tx: &mut Transaction<'_, Postgres>,
user: i64,
kind: &str,
id: &str,
) -> Result<Option<T>> {
let value: Option<Value> = sqlx::query_scalar("SELECT value FROM furumusic__podcast_register WHERE user_id=$1 AND kind=$2 AND entity_id=$3").bind(user).bind(kind).bind(id).fetch_optional(&mut **tx).await?;
Ok(value.map(serde_json::from_value).transpose()?)
}
async fn put<T: Serialize>(
tx: &mut Transaction<'_, Postgres>,
user: i64,
kind: &str,
id: &str,
value: &T,
) -> Result<()> {
sqlx::query("INSERT INTO furumusic__podcast_register(user_id,kind,entity_id,value) VALUES($1,$2,$3,$4) ON CONFLICT(user_id,kind,entity_id) DO UPDATE SET value=EXCLUDED.value").bind(user).bind(kind).bind(id).bind(serde_json::to_value(value)?).execute(&mut **tx).await?;
Ok(())
}
async fn begin(pool: &PgPool, user: i64) -> Result<Transaction<'_, Postgres>> {
let mut tx = pool.begin().await?;
sqlx::query("SELECT pg_advisory_xact_lock(hashtextextended($1,7512))")
.bind(format!("podcast-sync:{user}"))
.execute(&mut *tx)
.await?;
Ok(tx)
}
async fn project_subscription(
tx: &mut Transaction<'_, Postgres>,
user: i64,
id: &str,
) -> Result<()> {
let Some(sub) = get::<SubscriptionRecord>(tx, user, "subscription", id).await? else {
return Ok(());
};
let share = get::<ShareRecord>(tx, user, "share", id).await?;
let origin = sub
.feed_urls()
.into_iter()
.find(|url| PodcastId::from_feed_url(url) == sub.podcast_id)
.unwrap_or(sub.podcast.feed_url.clone());
sqlx::query("INSERT INTO furumusic__podcast(id,origin_url,feed_url,metadata) VALUES($1,$2,$3,$4) ON CONFLICT(id) DO UPDATE SET origin_url=EXCLUDED.origin_url").bind(id).bind(origin.as_str()).bind(sub.podcast.feed_url.as_str()).bind(json!(sub.podcast)).execute(&mut **tx).await?;
for alias in sub.feed_urls() {
sqlx::query("INSERT INTO furumusic__podcast_alias(url,podcast_id) VALUES($1,$2) ON CONFLICT DO NOTHING").bind(alias.as_str()).bind(id).execute(&mut **tx).await?;
}
if sub.subscribed {
let shared = effective_share(Some(&sub), share.as_ref());
sqlx::query("INSERT INTO furumusic__podcast_subscription(user_id,podcast_id,shared) VALUES($1,$2,$3) ON CONFLICT(user_id,podcast_id) DO UPDATE SET shared=EXCLUDED.shared,confirmed_urls=CASE WHEN EXCLUDED.shared THEN furumusic__podcast_subscription.confirmed_urls ELSE NULL END").bind(user).bind(id).bind(shared).execute(&mut **tx).await?;
} else {
sqlx::query(
"DELETE FROM furumusic__podcast_subscription WHERE user_id=$1 AND podcast_id=$2",
)
.bind(user)
.bind(id)
.execute(&mut **tx)
.await?;
}
Ok(())
}
async fn merge_sub(
tx: &mut Transaction<'_, Postgres>,
user: i64,
incoming: SubscriptionRecord,
) -> Result<()> {
incoming.validate()?;
let id = incoming.podcast_id.as_str();
let mut merged = match get::<SubscriptionRecord>(tx, user, "subscription", id).await? {
Some(current) => merge_subscription(&current, &incoming)?,
None => incoming.clone(),
};
if let Some(aliases) = get::<Vec<FeedUrl>>(tx, user, "aliases", id).await? {
merged.add_feed_aliases(&aliases);
}
put(tx, user, "subscription", id, &merged).await?;
project_subscription(tx, user, id).await
}
async fn merge_shared(
tx: &mut Transaction<'_, Postgres>,
user: i64,
incoming: ShareRecord,
local: bool,
) -> Result<()> {
let id = incoming.podcast_id.as_str();
let current = get::<ShareRecord>(tx, user, "share", id).await?;
let merged = match &current {
Some(current) => merge_share(current, &incoming)?,
None => incoming.clone(),
};
if !local && current.as_ref().map(|r| r.op_id.as_str()) != Some(merged.op_id.as_str()) {
sqlx::query("UPDATE furumusic__podcast_subscription SET confirmed_urls=NULL WHERE user_id=$1 AND podcast_id=$2").bind(user).bind(id).execute(&mut **tx).await?;
}
put(tx, user, "share", id, &merged).await?;
project_subscription(tx, user, id).await
}
async fn merge_resume(
tx: &mut Transaction<'_, Postgres>,
user: i64,
incoming: ProgressRecord,
) -> Result<()> {
incoming.validate()?;
let id = incoming.episode_id.as_str();
let merged = match get::<ProgressRecord>(tx, user, "progress", id).await? {
Some(current) => merge_progress(&current, &incoming)?,
None => incoming.clone(),
};
put(tx, user, "progress", id, &merged).await?;
project_resume(tx, user, &merged).await
}
async fn project_resume(
tx: &mut Transaction<'_, Postgres>,
user: i64,
record: &ProgressRecord,
) -> Result<()> {
sqlx::query("INSERT INTO furumusic__podcast_progress(user_id,episode_id,position_ms,completed,generation,checkpoint) SELECT $1,id,$3,$4,$5,0 FROM furumusic__podcast_episode WHERE id=$2 ON CONFLICT(user_id,episode_id) DO UPDATE SET position_ms=EXCLUDED.position_ms,completed=EXCLUDED.completed,generation=EXCLUDED.generation").bind(user).bind(record.episode_id.as_str()).bind(record.position_ms).bind(record.status==ProgressStatus::Completed).bind(record.generation.min(i64::MAX as u64) as i64).execute(&mut **tx).await?;
Ok(())
}
async fn merge_session(
tx: &mut Transaction<'_, Postgres>,
user: i64,
incoming: ListenSession,
) -> Result<()> {
incoming.validate()?;
let id = &incoming.session_id;
let merged = match get::<ListenSession>(tx, user, "session", id).await? {
Some(current) => merge_listen_session(&current, &incoming)?,
None => incoming.clone(),
};
put(tx, user, "session", id, &merged).await
}
/// Applying the same operation again is safe, including after a crash between
/// persisting its log entry and updating the projection.
pub async fn apply_op(pool: &PgPool, user: i64, op: &SyncOpWire) -> Result<bool> {
let mut tx = begin(pool, user).await?;
apply_op_tx(&mut tx, user, op).await?;
tx.commit().await?;
Ok(true)
}
pub(crate) async fn apply_op_tx(
tx: &mut Transaction<'_, Postgres>,
user: i64,
op: &SyncOpWire,
) -> Result<bool> {
op.validate_podcast()?;
let reference = match &op.payload {
SyncOpPayload::PodcastProgressSet { episode, .. }
| SyncOpPayload::PodcastListenRecorded { episode, .. } => episode.as_ref(),
_ => None,
};
if let Some(reference) = reference {
materialize_reference(tx, reference).await?;
}
if let Some(sub) = op.podcast_subscription() {
merge_sub(tx, user, sub).await?;
} else if let Some(share) = op.podcast_share() {
let local:bool=sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM furumusic__fed_device_identity WHERE user_id=$1 AND device_id=$2)").bind(user).bind(&op.origin_device_id).fetch_one(&mut **tx).await?;
merge_shared(tx, user, share, local).await?;
} else if let Some((id, aliases)) = op.podcast_feed_aliases() {
let current = get::<Vec<FeedUrl>>(tx, user, "aliases", id.as_str())
.await?
.unwrap_or_default();
let merged = music_dht::podcast::merge_feed_aliases(id, &current, aliases);
put(tx, user, "aliases", id.as_str(), &merged).await?;
if let Some(mut sub) =
get::<SubscriptionRecord>(tx, user, "subscription", id.as_str()).await?
{
sub.add_feed_aliases(aliases);
put(tx, user, "subscription", id.as_str(), &sub).await?;
project_subscription(tx, user, id.as_str()).await?;
}
} else if let Some(progress) = op.podcast_progress() {
merge_resume(tx, user, progress).await?;
} else if let Some(session) = op.podcast_listen_session() {
merge_session(tx, user, session.clone()).await?;
}
Ok(true)
}
async fn materialize_reference(
tx: &mut Transaction<'_, Postgres>,
reference: &music_dht::podcast::PodcastEpisodeRef,
) -> Result<()> {
reference.validate()?;
let podcast = PodcastMeta {
feed_url: reference.feed_url.clone(),
title: reference.podcast_title.clone(),
author: None,
description: None,
link: None,
image_url: reference.image_url.clone(),
};
sqlx::query("INSERT INTO furumusic__podcast(id,origin_url,feed_url,metadata) VALUES($1,$2,$2,$3) ON CONFLICT DO NOTHING").bind(reference.podcast_id.as_str()).bind(reference.feed_url.as_str()).bind(json!(podcast)).execute(&mut **tx).await?;
let episode = EpisodeMeta {
episode_id: reference.episode_id.clone(),
podcast_id: reference.podcast_id.clone(),
guid: None,
title: reference.episode_title.clone(),
description: None,
season: reference.season,
episode_number: reference.episode_number,
episode_type: music_dht::podcast::EpisodeType::Full,
published_at_ms: reference.published_at_ms,
duration_ms: reference.duration_ms,
audio_url: reference.audio_url.clone(),
mime: reference.mime.clone(),
byte_len: None,
image_url: reference.image_url.clone(),
link: None,
};
sqlx::query("INSERT INTO furumusic__podcast_episode(id,podcast_id,metadata) VALUES($1,$2,$3) ON CONFLICT DO NOTHING").bind(reference.episode_id.as_str()).bind(reference.podcast_id.as_str()).bind(json!(episode)).execute(&mut **tx).await?;
Ok(())
}
pub async fn apply_snapshot(pool: &PgPool, user: i64, snapshot: &SyncSnapshot) -> Result<()> {
if !snapshot.podcast_state_within_limits() {
bail!("podcast snapshot exceeds contract limits");
}
let mut tx = begin(pool, user).await?;
for sub in &snapshot.podcast_subscriptions {
merge_sub(&mut tx, user, sub.clone()).await?;
}
for share in &snapshot.podcast_shares {
merge_shared(&mut tx, user, share.clone(), false).await?;
}
for progress in &snapshot.podcast_progress {
merge_resume(&mut tx, user, progress.clone()).await?;
}
for session in &snapshot.podcast_listen_sessions {
merge_session(&mut tx, user, session.clone()).await?;
}
tx.commit().await?;
Ok(())
}
pub async fn append_snapshot(pool: &PgPool, user: i64, snapshot: &mut SyncSnapshot) -> Result<()> {
seed_user(pool, user).await?;
let rows = sqlx::query(
"SELECT kind,value FROM furumusic__podcast_register WHERE user_id=$1 ORDER BY entity_id",
)
.bind(user)
.fetch_all(pool)
.await?;
for row in rows {
let value: Value = row.get("value");
match row.get::<&str, _>("kind") {
"subscription" => snapshot
.podcast_subscriptions
.push(serde_json::from_value(value)?),
"share" => snapshot.podcast_shares.push(serde_json::from_value(value)?),
"progress" => snapshot
.podcast_progress
.push(serde_json::from_value(value)?),
"session" => snapshot
.podcast_listen_sessions
.push(serde_json::from_value(value)?),
_ => {}
}
}
snapshot.bound_podcast_state();
Ok(())
}
pub async fn local_subscription(
pool: &PgPool,
user: i64,
id: &str,
subscribed: bool,
) -> Result<()> {
let mut tx = begin(pool, user).await?;
let sub = get::<SubscriptionRecord>(&mut tx, user, "subscription", id).await?;
let share = get::<ShareRecord>(&mut tx, user, "share", id).await?;
let generation = next_podcast_generation(sub.as_ref(), share.as_ref());
let row = sqlx::query("SELECT metadata,origin_url FROM furumusic__podcast WHERE id=$1")
.bind(id)
.fetch_one(&mut *tx)
.await?;
let podcast: PodcastMeta = serde_json::from_value(row.get("metadata"))?;
let origin = FeedUrl::parse(row.get::<&str, _>("origin_url"))?;
let mut aliases = sub.as_ref().map(|s| s.feed_urls()).unwrap_or_default();
aliases.push(origin);
let podcast_id: PodcastId = serde_json::from_value(json!(id))?;
let aliases = music_dht::podcast::merge_feed_aliases(&podcast_id, &[], &aliases);
tx.commit().await?;
crate::federation::devices::record_podcast_op(
pool,
user,
SyncOpPayload::PodcastSubscriptionSet {
podcast_id,
subscribed,
podcast,
feed_aliases: aliases,
generation,
},
)
.await?;
if !subscribed {
local_share(pool, user, id, false).await?;
}
Ok(())
}
pub async fn local_share(pool: &PgPool, user: i64, id: &str, shared: bool) -> Result<()> {
let mut tx = begin(pool, user).await?;
let sub = get::<SubscriptionRecord>(&mut tx, user, "subscription", id).await?;
let share = get::<ShareRecord>(&mut tx, user, "share", id).await?;
let generation = next_podcast_generation(sub.as_ref(), share.as_ref());
tx.commit().await?;
crate::federation::devices::record_podcast_op(
pool,
user,
SyncOpPayload::PodcastShareSet {
podcast_id: serde_json::from_value(json!(id))?,
shared,
generation,
},
)
.await
}
pub async fn seed_user(pool: &PgPool, user: i64) -> Result<()> {
let rows=sqlx::query("SELECT s.podcast_id,s.shared FROM furumusic__podcast_subscription s WHERE user_id=$1 AND NOT EXISTS(SELECT 1 FROM furumusic__podcast_register r WHERE r.user_id=s.user_id AND r.entity_id=s.podcast_id AND r.kind='subscription')").bind(user).fetch_all(pool).await?;
for row in rows {
let id: String = row.get("podcast_id");
let shared: bool = row.get("shared");
local_subscription(pool, user, &id, true).await?;
if shared {
local_share(pool, user, &id, true).await?;
}
}
Ok(())
}
pub async fn ensure_subscribed(pool: &PgPool, user: i64, id: &str) -> Result<()> {
let active:bool=sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM furumusic__podcast_register WHERE user_id=$1 AND kind='subscription' AND entity_id=$2 AND value->>'subscribed'='true')").bind(user).bind(id).fetch_one(pool).await?;
if !active {
local_subscription(pool, user, id, true).await?;
}
Ok(())
}
pub async fn local_progress(
pool: &PgPool,
user: i64,
id: &str,
generation: u64,
position: i64,
completed: bool,
) -> Result<()> {
let row=sqlx::query("SELECT g.*,e.metadata AS episode,p.metadata AS podcast FROM furumusic__podcast_progress g JOIN furumusic__podcast_episode e ON e.id=g.episode_id JOIN furumusic__podcast p ON p.id=e.podcast_id WHERE g.user_id=$1 AND g.episode_id=$2").bind(user).bind(id).fetch_one(pool).await?;
let episode: EpisodeMeta = serde_json::from_value(row.get("episode"))?;
let podcast: PodcastMeta = serde_json::from_value(row.get("podcast"))?;
crate::federation::devices::record_podcast_op(
pool,
user,
SyncOpPayload::PodcastProgressSet {
episode_id: episode.episode_id.clone(),
podcast_id: episode.podcast_id.clone(),
position_ms: position,
status: if completed {
ProgressStatus::Completed
} else if position > 0 {
ProgressStatus::InProgress
} else {
ProgressStatus::NotStarted
},
generation,
session_id: format!("web:{user}:{id}:{generation}"),
episode: Some(episode.to_ref(&podcast)),
},
)
.await
}
pub async fn restore_episode_progress(tx: &mut Transaction<'_, Postgres>, id: &str) -> Result<()> {
let rows=sqlx::query("SELECT user_id,value FROM furumusic__podcast_register WHERE kind='progress' AND entity_id=$1").bind(id).fetch_all(&mut **tx).await?;
for row in rows {
project_resume(
tx,
row.get("user_id"),
&serde_json::from_value(row.get("value"))?,
)
.await?;
}
Ok(())
}
pub fn refresh_received(pool: PgPool) {
static WORKER: tokio::sync::Semaphore = tokio::sync::Semaphore::const_new(1);
let Ok(permit) = WORKER.try_acquire() else {
return;
};
tokio::spawn(async move {
let _permit = permit;
let ids:Vec<String>=sqlx::query_scalar("SELECT DISTINCT p.id FROM furumusic__podcast p JOIN furumusic__podcast_subscription s ON s.podcast_id=p.id WHERE p.checked_at IS NULL LIMIT 20").fetch_all(&pool).await.unwrap_or_default();
for id in ids {
let _ = refresh(&pool, &id).await;
}
});
}
+6
View File
@@ -0,0 +1,6 @@
CREATE TABLE IF NOT EXISTS furumusic__podcast_register (
user_id BIGINT NOT NULL REFERENCES furumusic__user(id) ON DELETE CASCADE,
kind TEXT NOT NULL, entity_id TEXT NOT NULL, value JSONB NOT NULL,
PRIMARY KEY(user_id,kind,entity_id)
);
CREATE COLLATION IF NOT EXISTS furumusic_unicode (provider=icu, locale='und', deterministic=true);
+87
View File
@@ -82,6 +82,14 @@ async fn postgres_multiuser_progress_retention_and_admin() {
.execute(&pool)
.await
.unwrap();
for source in [
include_str!("sync_schema.sql"),
include_str!("../../tests/podcast_sync_fixture.sql"),
] {
for statement in source.split(';').filter(|s| !s.trim().is_empty()) {
sqlx::query(statement).execute(&pool).await.unwrap();
}
}
let origin = FeedUrl::parse("https://example.test/feed.xml").unwrap();
let podcast = PodcastId::from_feed_url(&origin);
let feed=parse_feed_with_base(br#"<rss><channel><title>Fixture</title><item><title>Episode</title><guid>one</guid><enclosure url="https://example.test/audio.mp3"/></item></channel></rss>"#,Some(origin.as_str())).unwrap();
@@ -273,6 +281,85 @@ async fn postgres_multiuser_progress_retention_and_admin() {
.unwrap()
.is_empty()
);
// An actual v4 wire operation, as emitted by the TUI, creates the web
// subscription without HTTP fetching or a second manual subscription.
let url = FeedUrl::parse("https://example.test/tui-feed").unwrap();
let id = PodcastId::from_feed_url(&url);
let incoming:music_dht::device_sync::SyncOpWire=serde_json::from_value(json!({"op_id":"tui_test:1","origin_device_id":"tui_test","seq":1,"hlc_ms":42,"payload":{"kind":"podcast_subscription_set","podcast_id":id,"subscribed":true,"podcast":{"feed_url":url,"title":"ТАЙНЫ Космоса","description":"История МУЗЫКИ и Ελληνικά"},"feed_aliases":[url],"generation":1}})).unwrap();
sync::apply_op(&pool, 1, &incoming).await.unwrap();
assert_eq!(
list(&pool, 1, false).await.unwrap()["mine"][0]["id"],
json!(id)
);
assert_eq!(
super::super::search(&pool, 1, "тайны музыка", 10)
.await
.unwrap()
.len(),
0
);
for query in [
"тайны космоса",
"ТАЙНЫ КОСМОСА",
"история музыки",
"ελληνικά",
"ΕΛΛΗΝΙΚΆ",
] {
assert_eq!(
super::super::search(&pool, 1, query, 10)
.await
.unwrap()
.len(),
1,
"{query}"
);
}
assert!(
super::super::search(&pool, 2, "тайны", 10)
.await
.unwrap()
.is_empty()
);
let mut before = music_dht::device_sync::SyncSnapshot::default();
sync::append_snapshot(&pool, 1, &mut before).await.unwrap();
assert!(!before.for_peer(3).has_podcast_state());
// Simulate the same person's next connected device using another local
// user id, since local database user ids are not part of the wire contract.
sync::apply_snapshot(&pool, 2, &before).await.unwrap();
assert_eq!(
list(&pool, 2, false).await.unwrap()["mine"][0]["id"],
json!(id)
);
sync::local_subscription(&pool, 1, id.as_str(), false)
.await
.unwrap();
let mut after = music_dht::device_sync::SyncSnapshot::default();
sync::append_snapshot(&pool, 1, &mut after).await.unwrap();
sync::apply_snapshot(&pool, 2, &after).await.unwrap();
sync::apply_snapshot(&pool, 2, &before).await.unwrap();
sync::apply_op(&pool, 1, &incoming).await.unwrap();
assert!(
list(&pool, 1, false).await.unwrap()["mine"]
.as_array()
.unwrap()
.is_empty()
);
assert!(
list(&pool, 2, false).await.unwrap()["mine"]
.as_array()
.unwrap()
.is_empty()
);
let wire:music_dht::device_sync::SyncOpWire=serde_json::from_value(sqlx::query_scalar::<_,Value>("SELECT jsonb_build_object('op_id',op_id,'origin_device_id',origin_device_id,'seq',seq,'hlc_ms',hlc_ms,'payload',payload_json) FROM furumusic__fed_sync_ops WHERE user_id=1 AND kind='podcast_subscription_set' ORDER BY seq DESC LIMIT 1").fetch_one(&pool).await.unwrap()).unwrap();
assert!(!wire.podcast_subscription().unwrap().subscribed);
assert!(!music_dht::device_sync::op_allowed_for_peer(
&wire.payload,
3
));
assert!(music_dht::device_sync::op_allowed_for_peer(
&wire.payload,
4
));
pool.close().await;
sqlx::query(&format!("DROP SCHEMA {schema} CASCADE"))
.execute(&admin_pool)
+46 -3
View File
@@ -107,6 +107,8 @@ async fn action(
"admin_list" => return list(&pool, user, true).await,
"add" => {
let id = subscribe(&pool, user, &body.url).await?;
sync::ensure_subscribed(&pool, user, &id).await?;
sync::seed_user(&pool, user).await?;
let checked = refresh(&pool, &id).await;
tokio::spawn(async move {
let _ = download_pending(&pool, &config, Some(&id)).await;
@@ -116,6 +118,8 @@ async fn action(
);
}
"remove" => {
require_subscription(&pool, user, &body.id).await?;
sync::local_subscription(&pool, user, &body.id, false).await?;
sqlx::query(
"DELETE FROM furumusic__podcast_subscription WHERE user_id=$1 AND podcast_id=$2",
)
@@ -126,6 +130,7 @@ async fn action(
}
"share" => {
require_subscription(&pool, user, &body.id).await?;
sync::seed_user(&pool, user).await?;
let row = sqlx::query("SELECT origin_url,metadata FROM furumusic__podcast WHERE id=$1")
.bind(&body.id)
.fetch_one(&pool)
@@ -147,6 +152,7 @@ async fn action(
return Ok(json!({"confirmation_required":true,"urls":urls}));
}
sqlx::query("UPDATE furumusic__podcast_subscription SET shared=$3,confirmed_urls=$4 WHERE user_id=$1 AND podcast_id=$2").bind(user).bind(&body.id).bind(body.shared).bind(if body.shared {Some(urls)} else {None}).execute(&pool).await?;
sync::local_share(&pool, user, &body.id, body.shared).await?;
}
"episodes" => {
require_subscription(&pool, user, &body.id).await?;
@@ -187,15 +193,36 @@ async fn action(
} else {
sqlx::query_scalar("UPDATE furumusic__podcast_progress SET position_ms=$3,completed=$4,checkpoint=$6,updated_at=now() WHERE user_id=$1 AND episode_id=$2 AND generation=$5 AND checkpoint<=$6 RETURNING generation").bind(user).bind(&body.id).bind(body.position_ms.max(0)).bind(completed).bind(body.generation).bind(body.sequence).fetch_optional(&pool).await?
};
if let Some(generation) = generation {
sync::local_progress(
&pool,
user,
&body.id,
generation.max(0) as u64,
body.position_ms.max(0),
completed,
)
.await?;
}
return Ok(json!({"ok":true,"generation":generation}));
}
"search" => {
if body.query.chars().count() < 2 || body.query.len() > 200 {
bail!("enter 2–200 characters");
}
let hits = crate::federation::handle()
.search_podcasts(&body.query)
.await?;
let mut hits = super::search(&pool, user, &body.query, 100).await?;
if let Ok(Ok(Value::Array(remote))) = tokio::time::timeout(
Duration::from_secs(10),
crate::federation::handle().search_podcasts(&body.query),
)
.await
{
for hit in remote {
if !hits.iter().any(|local| local["id"] == hit["id"]) {
hits.push(hit);
}
}
}
return Ok(json!({"hits":hits}));
}
"admin_settings" => {
@@ -211,9 +238,25 @@ async fn action(
.await?;
}
"admin_unpublish" => {
let owners:Vec<i64>=sqlx::query_scalar("SELECT user_id FROM furumusic__podcast_subscription WHERE podcast_id=$1 AND shared").bind(&body.id).fetch_all(&pool).await?;
for owner in owners {
sync::seed_user(&pool, owner).await?;
sync::local_share(&pool, owner, &body.id, false).await?;
}
sqlx::query("UPDATE furumusic__podcast_subscription SET shared=false,confirmed_urls=NULL WHERE podcast_id=$1").bind(&body.id).execute(&pool).await?;
}
"admin_clear" | "admin_delete" => {
if body.action == "admin_delete" {
let owners: Vec<i64> = sqlx::query_scalar(
"SELECT user_id FROM furumusic__podcast_subscription WHERE podcast_id=$1",
)
.bind(&body.id)
.fetch_all(&pool)
.await?;
for owner in owners {
sync::local_subscription(&pool, owner, &body.id, false).await?;
}
}
let mut tx = pool.begin().await?;
let locked: bool =
sqlx::query_scalar("SELECT pg_try_advisory_xact_lock(hashtextextended($1,7421))")
+32 -10
View File
@@ -5,6 +5,8 @@
add: ['Add', 'Добавить'],
mine: ['My podcasts', 'Мои подкасты'],
public: ['Public podcasts', 'Публичные подкасты'],
results: ['Podcast search results','Результаты поиска подкастов'],
noMatches: ['No matching podcasts.','Подходящих подкастов нет.'],
empty: ['Add an RSS or Atom feed.', 'Добавьте RSS или Atom ленту.'],
check: ['Check episodes', 'Проверить выпуски'],
checkAll: ['Check all', 'Проверить все'],
@@ -13,6 +15,7 @@
remove: ['Unsubscribe', 'Отписаться'],
subscribe: ['Subscribe', 'Подписаться'],
play: ['Play', 'Слушать'],
open: ['Open', 'Открыть'],
resume: ['Resume', 'Продолжить'],
download: ['Save on server', 'Сохранить на сервере'],
saved: ['Saved on server', 'Сохранено на сервере'],
@@ -28,7 +31,7 @@
description: ['Description', 'Описание'],
noEpisodes: ['No episodes in this filter.', 'В этом фильтре нет выпусков.'],
noPublic: ['No public podcasts yet.', 'Публичных подкастов пока нет.'],
searchNetwork: ['Search Frid podcasts', 'Поиск подкастов в Frid'],
searchNetwork: ['Search podcasts', 'Поиск подкастов'],
search: ['Search', 'Найти'],
working: ['Working…', 'Выполняется…'],
done: ['Done', 'Готово'],
@@ -58,6 +61,7 @@
mine: [],
public: [],
hits: [],
searched: false,
episodes: [],
hasMore: false,
selected: null,
@@ -105,9 +109,11 @@
this.public = data.public;
},
enter() {
if (location.hash !== '#podcasts')
Alpine.store('library')._beginNavigation('#podcasts');
Alpine.store('library').view = 'podcasts';
Alpine.store('mobile')?.closeLibrary();
this.task(async () => {
const loading = this.task(async () => {
await this.load();
this.message = '';
});
@@ -116,6 +122,7 @@
if (Alpine.store('library').view === 'podcasts' && !this.busy)
this.update().catch(() => {});
}, 5000);
return loading;
},
async update() {
await this.load();
@@ -133,11 +140,7 @@
const old = this.episodes;
this.episodes = append
? [...old, ...data.episodes]
: [
...new Map(
[...data.episodes, ...old].map((e) => [e.id, e]),
).values(),
];
: [...new Map([...data.episodes, ...old].map((e) => [e.id, e])).values()];
if (append || old.length <= 200) this.hasMore = !!data.has_more;
},
more() {
@@ -157,6 +160,21 @@
this.message = '';
});
},
openResult(pod) {
return this.task(async () => {
if (!pod.subscribed) await this.api('add', { url: pod.url });
await this.load();
this.selected = this.mine.find((p) => p.id === pod.id) || pod;
this.episodes = [];
this.hasMore = false;
this.filter = '';
this.season = '';
Alpine.store('library')._beginNavigation('#podcasts');
Alpine.store('library').view = 'podcasts';
await this.loadEpisodes();
this.message = '';
});
},
add(url) {
this.task(async () => {
const result = await this.api('add', { url: url || this.url });
@@ -232,14 +250,18 @@
});
},
search() {
this.task(async () => {
const data = await this.api('search', { query: this.query });
const query=this.query.trim();
return this.task(async () => {
const data = await this.api('search', { query });
if(this.query.trim()!==query){this.message='';return;}
this.hits = data.hits;
this.searched=true;
this.message = this.text('done');
});
},
resetSearch(){this.searched=false;this.hits=[];},
publicCards() {
return [...new Map([...this.public, ...this.hits].map((p) => [p.id, p])).values()];
return [...new Map((this.searched?this.hits:this.public).map((p) => [p.id, p])).values()];
},
seasons() {
return [
+8 -7
View File
@@ -1,7 +1,7 @@
<style>
.podcast-nav{appearance:none;border:0;background:transparent;width:100%;font:inherit;text-align:left}
.podcast-page{padding:20px;max-width:1100px;margin:auto}.podcast-toolbar{display:flex;gap:10px;align-items:center;flex-wrap:wrap;margin:16px 0}.podcast-toolbar input,.podcast-toolbar select{background:var(--bg-secondary,#171c28);color:inherit;border:1px solid var(--border,#384052);border-radius:8px;padding:10px;max-width:100%}.podcast-toolbar input[type=text]{flex:1;min-width:160px}.podcast-page button{border:1px solid var(--border,#384052);background:var(--bg-secondary,#171c28);color:inherit;border-radius:8px;padding:8px 12px;cursor:pointer}.podcast-page button:disabled{opacity:.5}.podcast-grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(min(280px,100%),1fr));gap:14px;margin:16px 0 28px}.podcast-card,.podcast-episode{border:1px solid var(--border,#384052);border-radius:12px;padding:16px;overflow-wrap:anywhere}.podcast-card h3,.podcast-episode h3{margin:0 0 8px}.podcast-description{color:var(--text-secondary,#a2a9b8);white-space:pre-line;margin:8px 0}.podcast-episode{margin:10px 0}.podcast-notice{padding:12px 0;color:var(--accent,#67e8f9)}@media(max-width:600px){.podcast-page{padding:12px}.podcast-page button,.podcast-page input,.podcast-page select{min-height:44px;font-size:16px}}
.podcast-page{padding:20px;max-width:1100px;margin:auto}.podcast-toolbar{display:flex;gap:10px;align-items:center;flex-wrap:wrap;margin:16px 0}.podcast-toolbar input,.podcast-toolbar select{background:var(--bg-secondary,#171c28);color:inherit;border:1px solid var(--border,#384052);border-radius:8px;padding:10px;max-width:100%}.podcast-toolbar input[type=text]{flex:1;min-width:160px}.podcast-page button,.podcast-card button{border:1px solid var(--border,#384052);background:var(--bg-secondary,#171c28);color:inherit;border-radius:8px;padding:8px 12px;cursor:pointer}.podcast-page button:disabled,.podcast-card button:disabled{opacity:.5}.podcast-grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(min(280px,100%),1fr));gap:14px;margin:16px 0 28px}.podcast-card,.podcast-episode{border:1px solid var(--border,#384052);border-radius:12px;padding:16px;overflow-wrap:anywhere}.podcast-card h3,.podcast-episode h3{margin:0 0 8px}.podcast-description{color:var(--text-secondary,#a2a9b8);white-space:pre-line;margin:8px 0}.podcast-episode{margin:10px 0}.podcast-notice{padding:12px 0;color:var(--accent,#67e8f9)}@media(max-width:600px){.podcast-page{padding:12px}.podcast-page button,.podcast-page input,.podcast-page select{min-height:44px;font-size:16px}}
</style>
<template x-if="$store.library.view === 'podcasts'">
<section class="podcast-page">
@@ -139,11 +139,12 @@
x-text="$store.podcasts.text('loadMore')"
></button></section
></template>
<h2 x-text="$store.podcasts.text('public')"></h2>
<h2 x-text="$store.podcasts.text($store.podcasts.searched?'results':'public')"></h2>
<form class="podcast-toolbar" @submit.prevent="$store.podcasts.search()">
<input
type="text"
x-model="$store.podcasts.query"
@input="$store.podcasts.resetSearch()"
:placeholder="$store.podcasts.text('searchNetwork')"
:aria-label="$store.podcasts.text('searchNetwork')"
minlength="2"
@@ -154,8 +155,8 @@
></button>
</form>
<p
x-show="!$store.podcasts.public.length&&!$store.podcasts.hits.length"
x-text="$store.podcasts.text('noPublic')"
x-show="!$store.podcasts.publicCards().length"
x-text="$store.podcasts.text($store.podcasts.searched?'noMatches':'noPublic')"
></p>
<div class="podcast-grid">
<template x-for="pod in $store.podcasts.publicCards()" :key="pod.id"
@@ -164,9 +165,9 @@
<div x-text="pod.metadata.author"></div>
<p class="podcast-description" x-text="pod.metadata.description"></p>
<button
@click="$store.podcasts.add(pod.url)"
:disabled="$store.podcasts.busy||$store.podcasts.mine.some(p=>p.id===pod.id)"
x-text="$store.podcasts.text('subscribe')"
@click="$store.podcasts.openResult(pod)"
:disabled="$store.podcasts.busy"
x-text="$store.podcasts.text(pod.subscribed||$store.podcasts.mine.some(p=>p.id===pod.id)?'open':'subscribe')"
></button></article
></template>
</div></section
+2
View File
@@ -2669,6 +2669,8 @@ document.addEventListener('alpine:init', () => {
if (view === 'artists' && !id) {
if (this.view !== 'artists' || this.artistsPage === 0) this.goArtists(options);
else if (options.restoreScroll) this._restoreScrollPosition(hash);
} else if (view === 'podcasts') {
Alpine.store('podcasts').enter();
} else if (view === 'uploads' && !id) {
if (this.view !== 'my_uploads' || this.artistsPage === 0) this.goMyUploads(options);
else if (options.restoreScroll) this._restoreScrollPosition(hash);
+15 -1
View File
@@ -440,13 +440,27 @@
</template>
<template x-if="!$store.library.searchLoading && $store.library.searchResults">
<div :class="{ 'similarity-unified-results': $store.library.similaritySearchLabel }">
<template x-if="!$store.library.similaritySearchError && $store.library.searchResults.artists.length === 0 && $store.library.searchResults.releases.length === 0 && $store.library.searchResults.tracks.length === 0">
<template x-if="!$store.library.similaritySearchError && $store.library.searchResults.artists.length === 0 && $store.library.searchResults.releases.length === 0 && $store.library.searchResults.tracks.length === 0 && !($store.library.searchResults.podcasts || []).length">
<div class="empty-state">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><circle cx="11" cy="11" r="8"/><line x1="21" y1="21" x2="16.65" y2="16.65"/></svg>
<p>{{ t.player_no_results }}</p>
</div>
</template>
<!-- Artists section -->
<template x-if="($store.library.searchResults.podcasts || []).length">
<section class="search-section">
<h2 class="search-section-title" x-text="$store.podcasts.text('podcasts')"></h2>
<div class="podcast-grid">
<template x-for="pod in $store.library.searchResults.podcasts" :key="pod.id">
<article class="podcast-card">
<h3><button @click="$store.podcasts.openResult(pod)" x-text="pod.metadata.title"></button></h3>
<p class="podcast-description" x-text="pod.metadata.description"></p>
<button @click="$store.podcasts.openResult(pod)" :disabled="$store.podcasts.busy" x-text="$store.podcasts.text(pod.subscribed?'open':'subscribe')"></button>
</article>
</template>
</div>
</section>
</template>
<template x-if="$store.library.searchResults.artists.length > 0">
<div class="search-section">
<h2 class="search-section-title">{{ t.player_artists }}</h2>
+15
View File
@@ -0,0 +1,15 @@
CREATE TABLE furumusic__fed_device_identity (
user_id BIGINT PRIMARY KEY, device_id TEXT NOT NULL, group_id TEXT NOT NULL,
device_name TEXT NOT NULL, local_seq BIGINT DEFAULT 0, last_hlc_ms BIGINT DEFAULT 0,
local_seeded_at_ms BIGINT NOT NULL DEFAULT 1
);
CREATE TABLE furumusic__fed_sync_ops (
user_id BIGINT, op_id TEXT, origin_device_id TEXT, seq BIGINT, kind TEXT,
payload_json JSONB, hlc_ms BIGINT, received_at_ms BIGINT, tombstone BOOLEAN,
PRIMARY KEY(user_id,op_id)
);
CREATE TABLE furumusic__fed_sync_vector (
user_id BIGINT, device_id TEXT, max_seq BIGINT, PRIMARY KEY(user_id,device_id)
);
INSERT INTO furumusic__fed_device_identity(user_id,device_id,group_id,device_name)
VALUES(1,'web_test_one','group_test','one'),(2,'web_test_two','group_test','two');
+19 -3
View File
@@ -4,12 +4,12 @@ const {test} = require('node:test');
const vm = require('node:vm');
const source = readFileSync(`${__dirname}/../templates/player/podcast_scripts.html`, 'utf8').replace(/<\/?script>/g, '');
function setup(responder=()=>({})) {
const calls=[],stores={library:{view:'artists'},mobile:{closeLibrary(){}},player:{_playLocal(track,options){this.currentTrack=track;this.options=options;},seek(){}}};
const calls=[],stores={library:{view:'artists',_beginNavigation(){}},mobile:{closeLibrary(){}},player:{_playLocal(track,options){this.currentTrack=track;this.options=options;},seek(){}}};
vm.runInNewContext(source,{
document:{documentElement:{lang:'ru'},addEventListener(_,fn){fn();}},
Alpine:{store(name,value){if(value)stores[name]=value;return stores[name];}},
fetch:async(url,options)=>{const body=JSON.parse(options.body);calls.push(body);return {ok:true,json:async()=>responder(body)};},
confirm:()=>true,setInterval:()=>1,Date,Map,Set,Blob,navigator:{sendBeacon(){}},
confirm:()=>true,setInterval:()=>1,Date,Map,Set,Blob,location:{hash:''},navigator:{sendBeacon(){}},
});
return {store:stores.podcasts,stores,calls};
}
@@ -44,7 +44,7 @@ test('marking unplayed is an explicit reset and advances the active session gene
test('filtering combines season, title and played status without mixing podcasts with music',()=>{
const {store}=setup();store.episodes=[{...episode},{...episode,id:'other',completed:true},{...episode,id:'season3',metadata:{...episode.metadata,season:3}}];
store.filter='epis';store.season='2';store.unplayedOnly=true;assert.deepEqual(Array.from(store.filteredEpisodes(),e=>e.id),[episode.id]);
store.public=[{id:'a',url:'origin'}];store.hits=[{id:'a',url:'origin'},{id:'b',url:'other'}];assert.equal(store.publicCards().length,2);
store.public=[{id:'a',url:'origin'}];store.hits=[{id:'a',url:'origin'},{id:'b',url:'other'}];store.searched=true;assert.equal(store.publicCards().length,2);
});
test('private URL publication requires a separate confirmation; revocation does not republish',async()=>{
const {store,calls}=setup(body=>body.action==='share'&&!body.confirmed?{confirmation_required:true,urls:['https://example.test/feed?token=private']}:body.action==='list'?{mine:[],public:[]}:{ok:true});
@@ -68,3 +68,19 @@ test('new episodes do not create gaps in previously loaded pages',async()=>{
await store.loadEpisodes();assert.equal(store.episodes.length,203);
assert.equal(store.episodes[0].id,'new');assert.ok(store.episodes.some(e=>e.id==='episode-199'));
});
test('opening podcast navigation starts polling and search results open existing subscriptions',async()=>{
const podcast={id:'show',metadata:{title:'Show'},subscribed:true};
const {store,stores,calls}=setup(body=>body.action==='list'?{mine:[podcast],public:[]}:body.action==='episodes'?{episodes:[],has_more:false}:{});
await store.enter();assert.equal(store.poller,1);assert.equal(stores.library.view,'podcasts');
stores.library.view='search';await store.openResult(podcast);
assert.equal(stores.library.view,'podcasts');assert.equal(store.selected.id,'show');
assert.equal(calls.filter(c=>c.action==='add').length,0);
});
test('podcast search displays matching results instead of retaining unrelated public cards',async()=>{
const {store}=setup(()=>({hits:[{id:'matching',metadata:{title:'Found'}}]}));
store.public=[{id:'unrelated'}];store.query='космос';await store.search();
assert.deepEqual(Array.from(store.publicCards(),p=>p.id),['matching']);
store.resetSearch();assert.deepEqual(Array.from(store.publicCards(),p=>p.id),['unrelated']);
});
+14
View File
@@ -0,0 +1,14 @@
CREATE TABLE furumusic__artist(id BIGINT PRIMARY KEY,name TEXT,is_hidden BOOLEAN DEFAULT false,updated_at TEXT DEFAULT '2026-01-01');
CREATE TABLE furumusic__release(id BIGINT PRIMARY KEY,title TEXT,year INTEGER,is_hidden BOOLEAN DEFAULT false,updated_at TEXT DEFAULT '2026-01-01');
CREATE TABLE furumusic__track(id BIGINT PRIMARY KEY,title TEXT,title_sort TEXT,release_id BIGINT,disc_number INTEGER,track_number INTEGER,duration_seconds DOUBLE PRECISION,is_hidden BOOLEAN DEFAULT false,updated_at TEXT DEFAULT '2026-01-01');
CREATE TABLE furumusic__release_artist(release_id BIGINT,artist_id BIGINT);
CREATE TABLE furumusic__track_artist(track_id BIGINT,artist_id BIGINT,role TEXT DEFAULT 'main');
CREATE TABLE furumusic__user_followed_artist(user_id BIGINT,artist_id BIGINT);
CREATE TABLE furumusic__track_ref(local_track_id BIGINT,content_id TEXT);
CREATE TABLE furumusic__listen_event(content_id TEXT,qualified BOOLEAN,user_id BIGINT,listen_id TEXT);
CREATE TABLE furumusic__playlist_track(track_id BIGINT,playlist_id BIGINT);
INSERT INTO furumusic__artist(id,name) VALUES(1,'Алиса');
INSERT INTO furumusic__release(id,title) VALUES(1,'СОЛНЦЕ');
INSERT INTO furumusic__track(id,title,title_sort,release_id,duration_seconds) VALUES(1,'Ελληνικά ТРЕК','ελληνικά трек',1,123);
INSERT INTO furumusic__release_artist VALUES(1,1);
INSERT INTO furumusic__track_artist(track_id,artist_id) VALUES(1,1);