Remove reduntant types

Author: joseivanlopez

rust/agama-server/src/network/web.rs

@@ -20,7 +20,7 @@
 
 //! This module implements the web API for the network module.
 
-use crate::{error::Error, web::EventsSender};
+use crate::error::Error;
 use anyhow::Context;
 use axum::{
     extract::{Path, State},
@@ -33,7 +33,7 @@ use uuid::Uuid;
 
 use agama_lib::{
     error::ServiceError,
-    event,
+    event, http,
     network::{
         error::NetworkStateError,
         model::{AccessPoint, Connection, Device, GeneralState},
@@ -85,7 +85,7 @@ struct NetworkServiceState {
 /// * `events`: sending-half of the broadcast channel.
 pub async fn network_service<T: Adapter + Send + Sync + 'static>(
     adapter: T,
-    events: EventsSender,
+    events: http::event::Sender,
 ) -> Result<Router, ServiceError> {
     let network = NetworkSystem::new(adapter);
     // FIXME: we are somehow abusing ServiceError. The HTTP/JSON API should have its own

rust/agama-server/src/software/web.rs

@@ -27,16 +27,13 @@
 
 use crate::{
     error::Error,
-    web::{
-        common::{service_status_router, EventStreams, ProgressClient, ProgressRouterBuilder},
-        EventsReceiver,
-    },
+    web::common::{service_status_router, EventStreams, ProgressClient, ProgressRouterBuilder},
 };
 
 use agama_lib::{
     error::ServiceError,
     event,
-    http::{Event, EventPayload},
+    http::{self, Event, EventPayload},
     product::{proxies::RegistrationProxy, Product, ProductClient},
     software::{
         model::{
@@ -221,7 +218,7 @@ fn reason_to_selected_by(
 /// * `events`: channel to listen for events.
 /// * `products`: list of products (shared behind a mutex).
 pub async fn receive_events(
-    mut events: EventsReceiver,
+    mut events: http::event::Receiver,
     products: Arc<RwLock<Vec<Product>>>,
     config: Arc<RwLock<Option<SoftwareConfig>>>,
     client: ProductClient<'_>,
@@ -265,7 +262,7 @@ pub async fn receive_events(
 /// Sets up and returns the axum service for the software module.
 pub async fn software_service(
     dbus: zbus::Connection,
-    events: EventsReceiver,
+    events: http::event::Receiver,
     progress: ProgressClient,
 ) -> Result<Router, ServiceError> {
     const DBUS_SERVICE: &str = "org.opensuse.Agama.Software1";

rust/agama-server/src/web.rs

@@ -47,16 +47,18 @@ mod auth;
 pub mod common;
 mod config;
 pub mod docs;
-mod event;
 mod http;
 mod service;
 mod state;
 mod ws;
 
-use agama_lib::{connection, error::ServiceError, http::Event};
+use agama_lib::{
+    connection,
+    error::ServiceError,
+    http::event::{self, Event},
+};
 use common::ProgressService;
 pub use config::ServiceConfig;
-pub use event::{EventsReceiver, EventsSender};
 pub use service::MainServiceBuilder;
 use std::path::Path;
 use tokio_stream::{StreamExt, StreamMap};
@@ -69,7 +71,7 @@ use tokio_stream::{StreamExt, StreamMap};
 /// * `web_ui_dir`: public directory containing the web UI.
 pub async fn service<P>(
     config: ServiceConfig,
-    events: EventsSender,
+    events: event::Sender,
     dbus: zbus::Connection,
     web_ui_dir: P,
 ) -> Result<Router, ServiceError>
@@ -116,7 +118,7 @@ where
 /// The events are sent to the `events` channel.
 ///
 /// * `events`: channel to send the events to.
-pub async fn run_monitor(events: EventsSender) -> Result<(), ServiceError> {
+pub async fn run_monitor(events: event::Sender) -> Result<(), ServiceError> {
     let connection = connection().await?;
     tokio::spawn(run_events_monitor(connection, events.clone()));
 
@@ -127,7 +129,7 @@ pub async fn run_monitor(events: EventsSender) -> Result<(), ServiceError> {
 ///
 /// * `connection`: D-Bus connection.
 /// * `events`: channel to send the events to.
-async fn run_events_monitor(dbus: zbus::Connection, events: EventsSender) -> Result<(), Error> {
+async fn run_events_monitor(dbus: zbus::Connection, events: event::Sender) -> Result<(), Error> {
     let mut stream = StreamMap::new();
 
     stream.insert("manager", manager_stream(dbus.clone()).await?);

rust/agama-server/src/web/common/progress.rs

@@ -35,10 +35,9 @@
 //!
 //! At this point, it only handles the progress that are exposed through D-Bus.
 
-use crate::web::EventsSender;
 use agama_lib::{
     event,
-    http::Event,
+    http::{self, Event},
     progress::{Progress, ProgressSequence},
     proxies::{ProgressChanged, ProgressProxy},
 };
@@ -77,7 +76,7 @@ pub enum ProgressCommand {
 pub struct ProgressService {
     cache: HashMap<String, ProgressSequence>,
     commands: mpsc::Receiver<ProgressCommand>,
-    events: EventsSender,
+    events: http::event::Sender,
     dbus: zbus::Connection,
 }
 
@@ -88,7 +87,7 @@ impl ProgressService {
     ///
     /// * Commands from a client ([ProgressClient]).
     /// * Relevant events from D-Bus.
-    pub async fn start(dbus: zbus::Connection, events: EventsSender) -> ProgressClient {
+    pub async fn start(dbus: zbus::Connection, events: http::event::Sender) -> ProgressClient {
         let (tx, rx) = mpsc::channel(4);
         let mut service = ProgressService {
             cache: HashMap::new(),

rust/agama-server/src/web/event.rs

@@ -19,8 +19,8 @@
 // find current contact information at www.suse.com.
 
 use super::http::{login, login_from_query, logout, session};
-use super::{config::ServiceConfig, state::ServiceState, EventsSender};
-use agama_lib::auth::TokenClaims;
+use super::{config::ServiceConfig, state::ServiceState};
+use agama_lib::{auth::TokenClaims, http};
 use axum::http::HeaderValue;
 use axum::middleware::Next;
 use axum::{
@@ -55,7 +55,7 @@ use tracing::Span;
 /// * A number of authenticated services that are added using the `add_service` function.
 pub struct MainServiceBuilder {
     config: ServiceConfig,
-    events: EventsSender,
+    events: http::event::Sender,
     api_router: Router<ServiceState>,
     public_dir: PathBuf,
 }
@@ -65,7 +65,7 @@ impl MainServiceBuilder {
     ///
     /// * `events`: channel to send events through the WebSocket.
     /// * `public_dir`: path to the public directory.
-    pub fn new<P>(events: EventsSender, public_dir: P) -> Self
+    pub fn new<P>(events: http::event::Sender, public_dir: P) -> Self
     where
         P: AsRef<Path>,
     {

rust/agama-server/src/web/service.rs

@@ -20,7 +20,8 @@
 
 //! Implements the web service state.
 
-use super::{config::ServiceConfig, EventsSender};
+use super::config::ServiceConfig;
+use agama_lib::http;
 use std::path::PathBuf;
 
 /// Web service state.
@@ -29,6 +30,6 @@ use std::path::PathBuf;
 #[derive(Clone)]
 pub struct ServiceState {
     pub config: ServiceConfig,
-    pub events: EventsSender,
+    pub events: http::event::Sender,
     pub public_dir: PathBuf,
 }

rust/agama-server/src/web/state.rs

@@ -20,10 +20,8 @@
 
 //! Implements the websocket handling.
 
-use std::sync::Arc;
-
-use super::{state::ServiceState, EventsSender};
-use agama_lib::auth::ClientId;
+use super::state::ServiceState;
+use agama_lib::{auth::ClientId, http};
 use axum::{
     extract::{
         ws::{Message, WebSocket},
@@ -32,6 +30,7 @@ use axum::{
     response::IntoResponse,
     Extension,
 };
+use std::sync::Arc;
 
 pub async fn ws_handler(
     State(state): State<ServiceState>,
@@ -41,7 +40,11 @@ pub async fn ws_handler(
     ws.on_upgrade(move |socket| handle_socket(socket, state.events, client_id))
 }
 
-async fn handle_socket(mut socket: WebSocket, events: EventsSender, client_id: Arc<ClientId>) {
+async fn handle_socket(
+    mut socket: WebSocket,
+    events: http::event::Sender,
+    client_id: Arc<ClientId>,
+) {
     let mut rx = events.subscribe();
 
     let conn_event = agama_lib::event!(ClientConnected, client_id.as_ref());