tools/publish/src/main.rs

mod app;
mod error;
mod rdf;
mod windows;
mod widget;
mod navigator;
mod theme;
mod args;

use std::sync::{Arc, RwLock};
use std::thread;
use clap::Parser;
use color_eyre::eyre::eyre;
use iced::futures::StreamExt;
use iced::Task;
use ldp::middleware::BasicAuthMiddleware;
use ldp::reqwest::{Client, Url};
use ldp::reqwest_middleware::ClientBuilder;
use ldp::traverse::Traverse;
use oxigraph::model::Dataset;
use tracing::{debug, debug_span, error, field};
use crate::app::{Message, Publisher};
use tracing_subscriber::layer::SubscriberExt;
use tracing_subscriber::util::SubscriberInitExt;
use tracing_subscriber::{EnvFilter, fmt};
use tracing_subscriber::fmt::format::FmtSpan;
use gl_search::{DocType, Document, Schema, SearchIndex};
use crate::args::{AppArgs, Command};
use crate::rdf::curie::CurieHelper;
use crate::rdf::ontology::Ontology;

fn main() -> color_eyre::Result<()> {
    let appender = tracing_appender::rolling::never("/tmp", "publisher-log");
    tracing_subscriber::registry()
        .with(fmt::layer().with_span_events(FmtSpan::CLOSE).with_writer(appender))
        .with(EnvFilter::from_default_env())
        .init();
    color_eyre::install()?;

    let ontology = Ontology::builder()
        .with_path("/home/alex/.local/share/org.graphofliberty.desktop/ontology")
        .build()
        .expect("Failed to build ontology");

    let mut index = SearchIndex::builder()
        .with_path("/home/alex/.local/share/org.graphofliberty.desktop/index")
        .build()
        .expect("Failed to build search index");

    let args = AppArgs::parse();
    match args.command {
        Some(Command::Search(args)) => {
            for doc in index.query(args.discriminant, &args.query, Schema::all_fields(), 5)? {
                println!("{}", doc.to_json(Schema::schema()));
            }
        }
        Some(Command::Reindex) => {
            let curie_helper = CurieHelper::new(Ontology::prefixes().clone());

            let writer = Arc::new(RwLock::new(index.writer()?));
            debug_span!("Clear Index").in_scope(|| {
                let mut writer = writer.write()?;
                writer.delete_all_documents()?;
                writer.commit()
            })?;

            let store = ontology.store();
            let writer_clone = writer.clone();
            let index_classes_thread = thread::spawn(move || {
                let span = debug_span!("Index Classes", documents = field::Empty).entered();
                let writer = writer_clone.read().unwrap();
                let count = gl_search::rdf::index_triples(DocType::RdfsClass, store, &*gl_search::language::ENGLISH_OR_UNTAGGED, &*writer)?;
                span.record("documents", count);
                Ok::<(), gl_search::SearchError>(())
            });

            let store = ontology.store();
            let writer_clone = writer.clone();
            let index_properties_thread = thread::spawn(move || {
                let span = debug_span!("Index Properties", documents = field::Empty).entered();
                let writer = writer_clone.read().unwrap();
                let count = gl_search::rdf::index_triples(DocType::RdfProperty, store, &*gl_search::language::ENGLISH_OR_UNTAGGED, &writer)?;
                span.record("documents", count);
                Ok::<(), gl_search::SearchError>(())
            });

            let store = ontology.store();
            let writer_clone = writer.clone();
            let index_concepts_thread = thread::spawn(move || {
                let span = debug_span!("Index Concepts", documents = field::Empty).entered();
                let writer = writer_clone.read().unwrap();
                let count = gl_search::rdf::index_triples(DocType::SkosConcept, store, &*gl_search::language::ENGLISH_OR_UNTAGGED, &writer)?;
                span.record("documents", count);
                Ok::<(), gl_search::SearchError>(())
            });

            let starting_url = Url::parse("http://fedora.quill.lan/rest/")?;
            let writer_clone = writer.clone();
            let runtime = tokio::runtime::Builder::new_multi_thread()
                .enable_all()
                .name("repository-traversal")
                .build()?;

            let traversal_task = runtime.spawn(async move {
                let http_client = ClientBuilder::new(Client::new())
                    .with(BasicAuthMiddleware::new(
                        "fedoraAdmin".to_string(),
                        Some("fedoraAdmin".to_string()),
                    ))
                    .build();

                let mut documents = 0usize;
                let mut traversal = Traverse::new(http_client, starting_url, None);
                while let Some(result) = traversal.next().await {
                    match result {
                        Ok(rdf_source) => {
                            let writer = writer_clone.read().unwrap();
                            documents += gl_search::rdf::index_entity(rdf_source.dataset(), &*gl_search::language::ENGLISH_OR_UNTAGGED, &writer)?;
                        }
                        Err(err) => error!(?err),
                    }
                }
                debug!(documents, "Repository Traversal");
                Ok::<(), gl_search::SearchError>(())
            });

            index_classes_thread.join().unwrap()?;
            index_properties_thread.join().unwrap()?;
            index_concepts_thread.join().unwrap()?;
            runtime.block_on(traversal_task)??;

            debug_span!("Commit").in_scope(|| {
                let mut writer = writer.write()?;
                writer.commit()
            })?;
        }
        None => {
            iced::daemon(Publisher::new, Publisher::update, Publisher::view)
                .title(Publisher::title)
                .subscription(Publisher::subscription)
                .run()?;
        }
    }

    Ok(())
}