kweepeer 0.1.2

A generic webservice for interactive query expansion, expansion is provided via various modules
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use axum::{extract::Query, extract::State, routing::get, Router};
use clap::Parser;
use std::collections::HashMap;
use std::path::PathBuf;
use std::sync::Arc;
use tower_http::trace::TraceLayer;
use tracing::info;

use serde_json::json;
use toml;
use utoipa::OpenApi;
use utoipa_swagger_ui::SwaggerUi;

use kweepeer::api::{ApiError, ApiResponse};
use kweepeer::*;

#[derive(Parser, Debug, Clone)]
struct Args {
    #[arg(
        short,
        long,
        default_value_os = "127.0.0.1:8080",
        help = "The host and port to bind to"
    )]
    bind: String,

    #[arg(
        long,
        default_value_t = false,
        help = "Output logging info on incoming requests"
    )]
    debug: bool,

    #[arg(long = "config", short, default_value = "config.toml")]
    config_path: PathBuf,
}

#[derive(OpenApi)]
#[openapi(
    paths(
        query_entrypoint,
        list_modules
    ),
    tags(
        (name = "kweepeer", description = "A generic webservice for interactive query expansion, expansion is provided via various modules")
    )
)]
pub struct ApiDoc;

#[tokio::main]
async fn main() {
    let args = Args::parse();

    if args.debug {
        tracing_subscriber::fmt()
            .with_max_level(tracing::Level::DEBUG)
            .init();
    }

    info!("Loading configuration from {}", &args.config_path.display());
    let toml_string =
        std::fs::read_to_string(&args.config_path).expect("Unable to read configuration file");
    let config: Config = toml::from_str(&toml_string).expect("Unable to parse configuration file");

    let mut state = QueryExpander::new().with_config(config);

    // Load all the modules
    state.load().expect("Failure whilst loading modules");

    let app = Router::new()
        .route("/", get(query_entrypoint))
        .route("/modules", get(list_modules))
        .merge(SwaggerUi::new("/swagger-ui").url("/api-doc/openapi.json", ApiDoc::openapi()))
        .layer(TraceLayer::new_for_http())
        .with_state(Arc::new(state));

    //allow trailing slashes as well: (conflicts with swagger-ui!)
    //let app = NormalizePathLayer::trim_trailing_slash().layer(app);

    eprintln!("[kweepeer] listening on {}", args.bind);
    let listener = tokio::net::TcpListener::bind(args.bind).await.unwrap();
    axum::serve(
        listener, app,
        //ServiceExt::<axum::http::Request<Body>>::into_make_service(app),
    )
    .await
    .unwrap();
}

#[utoipa::path(
    get,
    path = "/",
    params(
        ("q" = String, Query, description = "A query in Lucene syntax", allow_reserved),
        ("include" = String, Query, description = "Comma separated list of modules to include (by ID)", allow_reserved),
        ("exclude" = String, Query, description = "Comma separated list of modules to exclude (by ID)", allow_reserved),
    ),
    responses(
        (status = 200, description = "Query result",content(
            (String = "application/json"),
        )),
        (status = 404, body = apidocs::ApiError, description = "Return when the query is invalid or another error occurs", content_type = "application/json"),
    )
)]
/// Receive and process a query. This is the main entrypoint
async fn query_entrypoint(
    Query(params): Query<HashMap<String, String>>,
    state: State<Arc<QueryExpander>>,
) -> Result<ApiResponse, ApiError> {
    if let Some(querystring) = params.get("q") {
        let mut terms_map = TermExpansions::new();
        let (terms, query_template) = Term::extract_from_query(querystring);
        let params: QueryParams = (&params).into();
        state.expand_query_into(&mut terms_map, &terms, &params)?;
        let resolved_template =
            state.resolve_query_template(query_template.as_str(), &terms_map)?;
        Ok(ApiResponse::new_queryexpansion(
            terms_map,
            querystring,
            query_template,
            resolved_template,
        ))
    } else {
        Err(ApiError::MissingArgument("query"))
    }
}

#[utoipa::path(
    get,
    path = "/modules",
    params(
    ),
    responses(
        (status = 200, description = "Returns all available modules",content(
            (String = "application/json"),
        )),
    )
)]
async fn list_modules(state: State<Arc<QueryExpander>>) -> Result<ApiResponse, ApiError> {
    let mut modules = Vec::new();
    for module in state.modules() {
        modules.push(json!({"id": module.id(), "name": module.name(), "type": module.kind()}));
    }
    Ok(ApiResponse::Modules(modules))
}