sorted imports

rustfmt.toml

@@ -1 +1,2 @@
 imports_granularity = "Module"
+group_imports = "StdExternalCrate"

warpgate-admin/src/api/known_hosts_detail.rs

@@ -1,8 +1,9 @@
+use std::sync::Arc;
+
 use poem::web::Data;
 use poem_openapi::param::Path;
 use poem_openapi::{ApiResponse, OpenApi};
 use sea_orm::{DatabaseConnection, EntityTrait, ModelTrait};
-use std::sync::Arc;
 use tokio::sync::Mutex;
 use uuid::Uuid;
 pub struct Api;

warpgate-admin/src/api/known_hosts_list.rs

@@ -1,8 +1,9 @@
+use std::sync::Arc;
+
 use poem::web::Data;
 use poem_openapi::payload::Json;
 use poem_openapi::{ApiResponse, OpenApi};
 use sea_orm::{DatabaseConnection, EntityTrait};
-use std::sync::Arc;
 use tokio::sync::Mutex;
 use warpgate_db_entities::KnownHost;
 

warpgate-admin/src/api/logs.rs

@@ -1,9 +1,10 @@
+use std::sync::Arc;
+
 use chrono::{DateTime, Utc};
 use poem::web::Data;
 use poem_openapi::payload::Json;
 use poem_openapi::{ApiResponse, Object, OpenApi};
 use sea_orm::{ColumnTrait, DatabaseConnection, EntityTrait, QueryFilter, QueryOrder, QuerySelect};
-use std::sync::Arc;
 use tokio::sync::Mutex;
 use uuid::Uuid;
 use warpgate_db_entities::LogEntry;

warpgate-admin/src/api/recordings_detail.rs

@@ -1,3 +1,5 @@
+use std::sync::Arc;
+
 use bytes::Bytes;
 use futures::{SinkExt, StreamExt};
 use poem::error::{InternalServerError, NotFoundError};
@@ -9,7 +11,6 @@ use poem_openapi::payload::Json;
 use poem_openapi::{ApiResponse, OpenApi};
 use sea_orm::{DatabaseConnection, EntityTrait};
 use serde_json::json;
-use std::sync::Arc;
 use tokio::fs::File;
 use tokio::io::{AsyncBufReadExt, BufReader};
 use tokio::sync::Mutex;

warpgate-admin/src/api/sessions_detail.rs

@@ -1,9 +1,10 @@
+use std::sync::Arc;
+
 use poem::web::Data;
 use poem_openapi::param::Path;
 use poem_openapi::payload::Json;
 use poem_openapi::{ApiResponse, OpenApi};
 use sea_orm::{ColumnTrait, DatabaseConnection, EntityTrait, QueryFilter, QueryOrder};
-use std::sync::Arc;
 use tokio::sync::Mutex;
 use uuid::Uuid;
 use warpgate_common::{SessionSnapshot, State};

warpgate-admin/src/api/sessions_list.rs

@@ -1,4 +1,5 @@
-use super::pagination::{PaginatedResponse, PaginationParams};
+use std::sync::Arc;
+
 use futures::{SinkExt, StreamExt};
 use poem::session::Session;
 use poem::web::websocket::{Message, WebSocket};
@@ -8,10 +9,11 @@ use poem_openapi::param::Query;
 use poem_openapi::payload::Json;
 use poem_openapi::{ApiResponse, OpenApi};
 use sea_orm::{ColumnTrait, DatabaseConnection, EntityTrait, QueryFilter, QueryOrder};
-use std::sync::Arc;
 use tokio::sync::Mutex;
 use warpgate_common::{SessionSnapshot, State};
 
+use super::pagination::{PaginatedResponse, PaginationParams};
+
 pub struct Api;
 
 #[derive(ApiResponse)]

warpgate-admin/src/api/ssh_keys.rs

@@ -1,9 +1,10 @@
+use std::sync::Arc;
+
 use poem::web::Data;
 use poem_openapi::payload::Json;
 use poem_openapi::{ApiResponse, Object, OpenApi};
 use russh_keys::PublicKeyBase64;
 use serde::Serialize;
-use std::sync::Arc;
 use tokio::sync::Mutex;
 use warpgate_common::WarpgateConfig;
 

warpgate-admin/src/api/targets_list.rs

@@ -1,7 +1,8 @@
+use std::sync::Arc;
+
 use poem::web::Data;
 use poem_openapi::payload::Json;
 use poem_openapi::{ApiResponse, OpenApi};
-use std::sync::Arc;
 use tokio::sync::Mutex;
 use warpgate_common::{ConfigProvider, Target};
 

warpgate-admin/src/api/tickets_detail.rs

@@ -1,8 +1,9 @@
+use std::sync::Arc;
+
 use poem::web::Data;
 use poem_openapi::param::Path;
 use poem_openapi::{ApiResponse, OpenApi};
 use sea_orm::{DatabaseConnection, EntityTrait, ModelTrait};
-use std::sync::Arc;
 use tokio::sync::Mutex;
 use uuid::Uuid;
 

warpgate-admin/src/api/tickets_list.rs

@@ -1,10 +1,11 @@
+use std::sync::Arc;
+
 use anyhow::Context;
 use poem::web::Data;
 use poem_openapi::payload::Json;
 use poem_openapi::{ApiResponse, Object, OpenApi};
 use sea_orm::ActiveValue::Set;
 use sea_orm::{ActiveModelTrait, DatabaseConnection, EntityTrait};
-use std::sync::Arc;
 use tokio::sync::Mutex;
 use uuid::Uuid;
 use warpgate_common::helpers::hash::generate_ticket_secret;

warpgate-admin/src/api/users_list.rs

@@ -1,7 +1,8 @@
+use std::sync::Arc;
+
 use poem::web::Data;
 use poem_openapi::payload::Json;
 use poem_openapi::{ApiResponse, OpenApi};
-use std::sync::Arc;
 use tokio::sync::Mutex;
 use warpgate_common::{ConfigProvider, UserSnapshot};
 

warpgate-common/src/auth.rs

@@ -1,6 +1,7 @@
+use std::fmt::Debug;
+
 use crate::consts::TICKET_SELECTOR_PREFIX;
 use crate::Secret;
-use std::fmt::Debug;
 
 pub enum AuthSelector {
     User {

warpgate-common/src/config.rs

@@ -1,9 +1,10 @@
-use poem_openapi::{Object, Union};
-use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::path::PathBuf;
 use std::time::Duration;
 
+use poem_openapi::{Object, Union};
+use serde::{Deserialize, Serialize};
+
 use crate::helpers::otp::OtpSecretKey;
 use crate::Secret;
 

warpgate-common/src/config_providers/file.rs

@@ -1,3 +1,16 @@
+use std::collections::HashSet;
+use std::sync::Arc;
+
+use anyhow::Result;
+use async_trait::async_trait;
+use data_encoding::BASE64_MIME;
+use sea_orm::ActiveValue::Set;
+use sea_orm::{ActiveModelTrait, DatabaseConnection, EntityTrait};
+use tokio::sync::Mutex;
+use tracing::*;
+use uuid::Uuid;
+use warpgate_db_entities::Ticket;
+
 use super::ConfigProvider;
 use crate::helpers::hash::verify_password_hash;
 use crate::helpers::otp::verify_totp;
@@ -5,17 +18,6 @@ use crate::{
     AuthCredential, AuthResult, ProtocolName, Target, User, UserAuthCredential, UserSnapshot,
     WarpgateConfig,
 };
-use anyhow::Result;
-use async_trait::async_trait;
-use data_encoding::BASE64_MIME;
-use sea_orm::ActiveValue::Set;
-use sea_orm::{ActiveModelTrait, DatabaseConnection, EntityTrait};
-use std::collections::HashSet;
-use std::sync::Arc;
-use tokio::sync::Mutex;
-use tracing::*;
-use uuid::Uuid;
-use warpgate_db_entities::Ticket;
 
 pub struct FileConfigProvider {
     db: Arc<Mutex<DatabaseConnection>>,

warpgate-common/src/config_providers/mod.rs

@@ -1,16 +1,18 @@
 mod file;
-use crate::{ProtocolName, Secret, Target, UserSnapshot};
+use std::sync::Arc;
+
 use anyhow::Result;
 use async_trait::async_trait;
 use bytes::Bytes;
 pub use file::FileConfigProvider;
 use sea_orm::{ColumnTrait, DatabaseConnection, EntityTrait, QueryFilter};
-use std::sync::Arc;
 use tokio::sync::Mutex;
 use tracing::*;
 use uuid::Uuid;
 use warpgate_db_entities::Ticket;
 
+use crate::{ProtocolName, Secret, Target, UserSnapshot};
+
 pub enum AuthResult {
     Accepted { username: String },
     OtpNeeded,

warpgate-common/src/db/mod.rs

@@ -1,14 +1,16 @@
-use crate::helpers::fs::secure_file;
+use std::time::Duration;
-use crate::WarpgateConfig;
+
 use anyhow::Result;
 use sea_orm::sea_query::Expr;
 use sea_orm::{
     ConnectOptions, Database, DatabaseConnection, EntityTrait, QueryFilter, TransactionTrait,
 };
-use std::time::Duration;
 use warpgate_db_entities::LogEntry;
 use warpgate_db_migrations::migrate_database;
 
+use crate::helpers::fs::secure_file;
+use crate::WarpgateConfig;
+
 pub async fn connect_to_db(config: &WarpgateConfig) -> Result<DatabaseConnection> {
     let mut url = url::Url::parse(&config.store.database_url.expose_secret()[..])?;
     if url.scheme() == "sqlite" {

warpgate-common/src/eventhub.rs

@@ -1,4 +1,5 @@
 use std::sync::Arc;
+
 use tokio::sync::mpsc::error::SendError;
 use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender};
 use tokio::sync::{Mutex, MutexGuard};

warpgate-common/src/helpers/hash.rs

@@ -1,4 +1,3 @@
-use crate::Secret;
 use anyhow::Result;
 use argon2::password_hash::rand_core::OsRng;
 use argon2::password_hash::{PasswordHash, PasswordHasher, PasswordVerifier, SaltString};
@@ -7,6 +6,8 @@ use data_encoding::HEXLOWER;
 use password_hash::errors::Error;
 use rand::Rng;
 
+use crate::Secret;
+
 pub fn hash_password(password: &str) -> String {
     let salt = SaltString::generate(&mut OsRng);
     let argon2 = Argon2::default();

warpgate-common/src/helpers/otp.rs

@@ -1,11 +1,12 @@
 use std::time::SystemTime;
 
-use super::rng::get_crypto_rng;
-use crate::types::Secret;
 use bytes::Bytes;
 use rand::Rng;
 use totp_rs::{Algorithm, TOTP};
 
+use super::rng::get_crypto_rng;
+use crate::types::Secret;
+
 pub type OtpExposedSecretKey = Bytes;
 pub type OtpSecretKey = Secret<OtpExposedSecretKey>;
 

warpgate-common/src/helpers/serde_base64_secret.rs

@@ -1,8 +1,9 @@
-use super::serde_base64;
-use crate::Secret;
 use bytes::Bytes;
 use serde::Serializer;
 
+use super::serde_base64;
+use crate::Secret;
+
 pub fn serialize<S: Serializer>(secret: &Secret<Bytes>, serializer: S) -> Result<S::Ok, S::Error> {
     serde_base64::serialize(secret.expose_secret().as_ref(), serializer)
 }

warpgate-common/src/logging/database.rs

@@ -1,9 +1,8 @@
-use super::layer::ValuesLogLayer;
+use std::sync::Arc;
-use super::values::SerializedRecordValues;
+
 use once_cell::sync::OnceCell;
 use sea_orm::query::JsonValue;
 use sea_orm::{ActiveModelTrait, DatabaseConnection};
-use std::sync::Arc;
 use tokio::sync::Mutex;
 use tracing::*;
 use tracing_subscriber::registry::LookupSpan;
@@ -11,6 +10,9 @@ use tracing_subscriber::Layer;
 use uuid::Uuid;
 use warpgate_db_entities::LogEntry;
 
+use super::layer::ValuesLogLayer;
+use super::values::SerializedRecordValues;
+
 static LOG_SENDER: OnceCell<tokio::sync::broadcast::Sender<LogEntry::ActiveModel>> =
     OnceCell::new();
 

warpgate-common/src/logging/socket.rs

@@ -1,5 +1,3 @@
-use super::layer::ValuesLogLayer;
-use crate::WarpgateConfig;
 use bytes::BytesMut;
 use chrono::Local;
 use tokio::net::UnixDatagram;
@@ -7,6 +5,9 @@ use tracing::*;
 use tracing_subscriber::registry::LookupSpan;
 use tracing_subscriber::Layer;
 
+use super::layer::ValuesLogLayer;
+use crate::WarpgateConfig;
+
 static SKIP_KEY: &str = "is_socket_logging_error";
 
 pub async fn make_socket_logger_layer<S>(config: &WarpgateConfig) -> impl Layer<S>

warpgate-common/src/logging/values.rs

@@ -1,7 +1,8 @@
-use serde::Serialize;
 use std::collections::HashMap;
 use std::fmt::Debug;
 use std::ops::DerefMut;
+
+use serde::Serialize;
 use tracing::field::Visit;
 use tracing_core::Field;
 

warpgate-common/src/protocols/handle.rs

@@ -1,10 +1,12 @@
-use crate::{SessionId, SessionState, State, Target};
+use std::sync::Arc;
+
 use anyhow::{Context, Result};
 use sea_orm::{ColumnTrait, DatabaseConnection, EntityTrait, QueryFilter};
-use std::sync::Arc;
 use tokio::sync::Mutex;
 use warpgate_db_entities::Session;
 
+use crate::{SessionId, SessionState, State, Target};
+
 pub trait SessionHandle {
     fn close(&mut self);
 }

warpgate-common/src/protocols/mod.rs

@@ -1,9 +1,11 @@
 mod handle;
-use crate::Target;
+use std::net::SocketAddr;
+
 use anyhow::Result;
 use async_trait::async_trait;
 pub use handle::{SessionHandle, WarpgateServerHandle};
-use std::net::SocketAddr;
+
+use crate::Target;
 
 #[derive(Debug, thiserror::Error)]
 pub enum TargetTestError {

warpgate-common/src/recordings/mod.rs

@@ -1,8 +1,9 @@
-use bytes::Bytes;
-use sea_orm::{ActiveModelTrait, DatabaseConnection};
 use std::collections::HashMap;
 use std::path::PathBuf;
 use std::sync::Arc;
+
+use bytes::Bytes;
+use sea_orm::{ActiveModelTrait, DatabaseConnection};
 use tokio::sync::{broadcast, Mutex};
 use tracing::*;
 use uuid::Uuid;

warpgate-common/src/recordings/writer.rs

@@ -1,13 +1,10 @@
-use crate::helpers::fs::secure_file;
-use crate::try_block;
-
-use super::{Error, Result};
-use bytes::{Bytes, BytesMut};
-use sea_orm::{ActiveModelTrait, DatabaseConnection, EntityTrait};
 use std::collections::HashMap;
 use std::path::PathBuf;
 use std::sync::Arc;
 use std::time::{Duration, Instant};
+
+use bytes::{Bytes, BytesMut};
+use sea_orm::{ActiveModelTrait, DatabaseConnection, EntityTrait};
 use tokio::fs::File;
 use tokio::io::{AsyncWriteExt, BufWriter};
 use tokio::sync::{broadcast, mpsc, Mutex};
@@ -15,6 +12,10 @@ use tracing::*;
 use uuid::Uuid;
 use warpgate_db_entities::Recording;
 
+use super::{Error, Result};
+use crate::helpers::fs::secure_file;
+use crate::try_block;
+
 #[derive(Clone)]
 pub struct RecordingWriter {
     sender: mpsc::Sender<Bytes>,

warpgate-common/src/state.rs

@@ -1,14 +1,16 @@
-use crate::{ProtocolName, SessionHandle, SessionId, Target, WarpgateServerHandle};
-use anyhow::{Context, Result};
-use sea_orm::{ActiveModelTrait, DatabaseConnection, EntityTrait};
 use std::collections::HashMap;
 use std::net::SocketAddr;
 use std::sync::{Arc, Weak};
+
+use anyhow::{Context, Result};
+use sea_orm::{ActiveModelTrait, DatabaseConnection, EntityTrait};
 use tokio::sync::{broadcast, Mutex};
 use tracing::*;
 use uuid::Uuid;
 use warpgate_db_entities::Session;
 
+use crate::{ProtocolName, SessionHandle, SessionId, Target, WarpgateServerHandle};
+
 pub struct State {
     pub sessions: HashMap<SessionId, Arc<Mutex<SessionState>>>,
     db: Arc<Mutex<DatabaseConnection>>,

warpgate-common/src/types.rs

@@ -1,8 +1,9 @@
+use std::fmt::Debug;
+
 use bytes::Bytes;
 use data_encoding::HEXLOWER;
 use rand::Rng;
 use serde::{Deserialize, Serialize};
-use std::fmt::Debug;
 use uuid::Uuid;
 
 use crate::helpers::rng::get_crypto_rng;

warpgate-db-migrations/src/m00002_create_session.rs

@@ -2,10 +2,11 @@ use sea_orm::Schema;
 use sea_orm_migration::prelude::*;
 
 pub mod session {
-    use crate::m00001_create_ticket::ticket;
     use sea_orm::entity::prelude::*;
     use uuid::Uuid;
 
+    use crate::m00001_create_ticket::ticket;
+
     #[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
     #[sea_orm(table_name = "sessions")]
     pub struct Model {

warpgate-db-migrations/src/m00003_create_recording.rs

@@ -2,10 +2,11 @@ use sea_orm::Schema;
 use sea_orm_migration::prelude::*;
 
 pub mod recording {
-    use crate::m00002_create_session::session;
     use sea_orm::entity::prelude::*;
     use uuid::Uuid;
 
+    use crate::m00002_create_session::session;
+
     #[derive(Debug, Clone, PartialEq, Eq, EnumIter, DeriveActiveEnum)]
     #[sea_orm(rs_type = "String", db_type = "String(Some(16))")]
     pub enum RecordingKind {

warpgate-protocol-ssh/src/client/handler.rs

@@ -1,15 +1,17 @@
-use crate::known_hosts::{KnownHostValidationResult, KnownHosts};
+use std::pin::Pin;
-use crate::ConnectionError;
+
 use futures::FutureExt;
 use russh::client::Session;
 use russh_keys::key::PublicKey;
 use russh_keys::PublicKeyBase64;
-use std::pin::Pin;
 use tokio::sync::mpsc::UnboundedSender;
 use tokio::sync::oneshot;
 use tracing::*;
 use warpgate_common::{Services, SessionId, TargetSSHOptions};
 
+use crate::known_hosts::{KnownHostValidationResult, KnownHosts};
+use crate::ConnectionError;
+
 #[derive(Debug)]
 pub enum ClientHandlerEvent {
     HostKeyReceived(PublicKey),

warpgate-protocol-ssh/src/client/mod.rs

@@ -1,11 +1,10 @@
 mod channel_direct_tcpip;
 mod channel_session;
 mod handler;
-use self::handler::ClientHandlerEvent;
+use std::collections::HashMap;
-use super::{ChannelOperation, DirectTCPIPParams};
+use std::net::ToSocketAddrs;
-use crate::client::handler::ClientHandlerError;
+use std::sync::Arc;
-use crate::helpers::PublicKeyAsOpenSSH;
+
-use crate::keys::load_client_keys;
 use anyhow::{Context, Result};
 use bytes::Bytes;
 use channel_direct_tcpip::DirectTCPIPChannel;
@@ -15,9 +14,6 @@ use handler::ClientHandler;
 use russh::client::Handle;
 use russh::{Preferred, Sig};
 use russh_keys::key::{self, PublicKey};
-use std::collections::HashMap;
-use std::net::ToSocketAddrs;
-use std::sync::Arc;
 use tokio::sync::mpsc::error::SendError;
 use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender};
 use tokio::sync::{oneshot, Mutex};
@@ -26,6 +22,12 @@ use tracing::*;
 use uuid::Uuid;
 use warpgate_common::{SSHTargetAuth, Services, SessionId, TargetSSHOptions};
 
+use self::handler::ClientHandlerEvent;
+use super::{ChannelOperation, DirectTCPIPParams};
+use crate::client::handler::ClientHandlerError;
+use crate::helpers::PublicKeyAsOpenSSH;
+use crate::keys::load_client_keys;
+
 #[derive(Debug, thiserror::Error)]
 pub enum ConnectionError {
     #[error("Host key mismatch")]

warpgate-protocol-ssh/src/keys.rs

@@ -1,8 +1,9 @@
+use std::fs::{create_dir_all, File};
+use std::path::PathBuf;
+
 use anyhow::Result;
 use russh_keys::key::{KeyPair, SignatureHash};
 use russh_keys::{encode_pkcs8_pem, load_secret_key};
-use std::fs::{create_dir_all, File};
-use std::path::PathBuf;
 use tracing::*;
 use warpgate_common::helpers::fs::secure_directory;
 use warpgate_common::WarpgateConfig;

warpgate-protocol-ssh/src/lib.rs

@@ -6,7 +6,9 @@ pub mod helpers;
 mod keys;
 mod known_hosts;
 mod server;
-use crate::client::{RCCommand, RemoteClient};
+use std::fmt::Debug;
+use std::net::SocketAddr;
+
 use anyhow::Result;
 use async_trait::async_trait;
 pub use client::*;
@@ -14,13 +16,13 @@ pub use common::*;
 pub use keys::*;
 use russh_keys::PublicKeyBase64;
 pub use server::run_server;
-use std::fmt::Debug;
-use std::net::SocketAddr;
 use uuid::Uuid;
 use warpgate_common::{
     ProtocolName, ProtocolServer, Services, Target, TargetOptions, TargetTestError,
 };
 
+use crate::client::{RCCommand, RemoteClient};
+
 pub static PROTOCOL_NAME: ProtocolName = "SSH";
 
 #[derive(Clone)]

warpgate-protocol-ssh/src/server/mod.rs

@@ -2,20 +2,22 @@ mod russh_handler;
 mod service_output;
 mod session;
 mod session_handle;
-use crate::keys::load_host_keys;
+use std::fmt::Debug;
-use crate::server::session_handle::SSHSessionHandle;
+use std::net::SocketAddr;
+use std::sync::Arc;
+
 use anyhow::Result;
 use russh::MethodSet;
 pub use russh_handler::ServerHandler;
 pub use session::ServerSession;
-use std::fmt::Debug;
-use std::net::SocketAddr;
-use std::sync::Arc;
 use tokio::io::{AsyncRead, AsyncWrite};
 use tokio::net::TcpListener;
 use tracing::*;
 use warpgate_common::{Services, SessionStateInit};
 
+use crate::keys::load_host_keys;
+use crate::server::session_handle::SSHSessionHandle;
+
 pub async fn run_server(services: Services, address: SocketAddr) -> Result<()> {
     let russh_config = {
         let config = services.config.lock().await;

warpgate-protocol-ssh/src/server/service_output.rs

@@ -1,7 +1,8 @@
-use ansi_term::Colour;
-use anyhow::Result;
 use std::sync::atomic::AtomicBool;
 use std::sync::Arc;
+
+use ansi_term::Colour;
+use anyhow::Result;
 use tokio::sync::{mpsc, Mutex};
 
 pub const ERASE_PROGRESS_SPINNER: &str = "\r                        \r";

warpgate-protocol-ssh/src/server/session.rs

@@ -1,11 +1,10 @@
-use super::service_output::ServiceOutput;
+use std::borrow::Cow;
-use super::session_handle::SessionHandleCommand;
+use std::collections::hash_map::Entry::Vacant;
-use crate::compat::ContextExt;
+use std::collections::HashMap;
-use crate::server::service_output::ERASE_PROGRESS_SPINNER;
+use std::net::{Ipv4Addr, SocketAddr};
-use crate::{
+use std::str::FromStr;
-    ChannelOperation, ConnectionError, DirectTCPIPParams, PtyRequest, RCCommand, RCEvent, RCState,
+use std::sync::Arc;
-    RemoteClient, ServerChannelId, X11Request,
+
-};
 use ansi_term::Colour;
 use anyhow::{Context, Result};
 use bimap::BiMap;
@@ -14,12 +13,6 @@ use russh::server::Session;
 use russh::{CryptoVec, Sig};
 use russh_keys::key::PublicKey;
 use russh_keys::PublicKeyBase64;
-use std::borrow::Cow;
-use std::collections::hash_map::Entry::Vacant;
-use std::collections::HashMap;
-use std::net::{Ipv4Addr, SocketAddr};
-use std::str::FromStr;
-use std::sync::Arc;
 use tokio::sync::mpsc::{UnboundedReceiver, UnboundedSender};
 use tokio::sync::{oneshot, Mutex};
 use tracing::*;
@@ -35,6 +28,15 @@ use warpgate_common::{
     TargetOptions, TargetSSHOptions, WarpgateServerHandle,
 };
 
+use super::service_output::ServiceOutput;
+use super::session_handle::SessionHandleCommand;
+use crate::compat::ContextExt;
+use crate::server::service_output::ERASE_PROGRESS_SPINNER;
+use crate::{
+    ChannelOperation, ConnectionError, DirectTCPIPParams, PtyRequest, RCCommand, RCEvent, RCState,
+    RemoteClient, ServerChannelId, X11Request,
+};
+
 #[derive(Clone)]
 enum TargetSelection {
     None,

warpgate/src/commands/check.rs

@@ -1,8 +1,10 @@
-use crate::config::load_config;
-use anyhow::{Context, Result};
 use std::net::ToSocketAddrs;
+
+use anyhow::{Context, Result};
 use tracing::*;
 
+use crate::config::load_config;
+
 pub(crate) async fn command(cli: &crate::Cli) -> Result<()> {
     let config = load_config(&cli.config, true)?;
     config

warpgate/src/commands/client_keys.rs

@@ -1,7 +1,8 @@
-use crate::config::load_config;
 use anyhow::Result;
 use warpgate_protocol_ssh::helpers::PublicKeyAsOpenSSH;
 
+use crate::config::load_config;
+
 pub(crate) async fn command(cli: &crate::Cli) -> Result<()> {
     let config = load_config(&cli.config, true)?;
     let keys = warpgate_protocol_ssh::load_client_keys(&config)?;

warpgate/src/commands/hash.rs

@@ -1,6 +1,7 @@
+use std::io::stdin;
+
 use anyhow::Result;
 use dialoguer::theme::ColorfulTheme;
-use std::io::stdin;
 use warpgate_common::helpers::hash::hash_password;
 
 pub(crate) async fn command() -> Result<()> {

warpgate/src/commands/run.rs

@@ -1,7 +1,9 @@
-use crate::config::{load_config, watch_config};
+use std::net::ToSocketAddrs;
+
 use anyhow::Result;
 use futures::StreamExt;
-use std::net::ToSocketAddrs;
+#[cfg(target_os = "linux")]
+use sd_notify::NotifyState;
 use tracing::*;
 use warpgate_common::db::cleanup_db;
 use warpgate_common::logging::install_database_logger;
@@ -9,8 +11,7 @@ use warpgate_common::{ProtocolServer, Services};
 use warpgate_protocol_http::HTTPProtocolServer;
 use warpgate_protocol_ssh::SSHProtocolServer;
 
-#[cfg(target_os = "linux")]
+use crate::config::{load_config, watch_config};
-use sd_notify::NotifyState;
 
 pub(crate) async fn command(cli: &crate::Cli) -> Result<()> {
     let version = env!("CARGO_PKG_VERSION");

warpgate/src/commands/setup.rs

@@ -1,10 +1,10 @@
-use crate::config::load_config;
-use anyhow::Result;
-use dialoguer::theme::ColorfulTheme;
-use rcgen::generate_simple_self_signed;
 use std::fs::{create_dir_all, File};
 use std::io::Write;
 use std::path::{Path, PathBuf};
+
+use anyhow::Result;
+use dialoguer::theme::ColorfulTheme;
+use rcgen::generate_simple_self_signed;
 use tracing::*;
 use warpgate_common::helpers::fs::{secure_directory, secure_file};
 use warpgate_common::helpers::hash::hash_password;
@@ -13,6 +13,8 @@ use warpgate_common::{
     User, UserAuthCredential, WarpgateConfigStore,
 };
 
+use crate::config::load_config;
+
 pub(crate) async fn command(cli: &crate::Cli) -> Result<()> {
     let version = env!("CARGO_PKG_VERSION");
     info!("Welcome to Warpgate {version}");

warpgate/src/commands/test_target.rs

@@ -1,8 +1,9 @@
-use crate::config::load_config;
 use anyhow::Result;
 use tracing::*;
 use warpgate_common::{ProtocolServer, Services, Target, TargetTestError};
 
+use crate::config::load_config;
+
 pub(crate) async fn command(cli: &crate::Cli, target_name: &String) -> Result<()> {
     let config = load_config(&cli.config, true)?;
 

warpgate/src/config.rs

@@ -1,8 +1,9 @@
+use std::path::Path;
+use std::sync::Arc;
+
 use anyhow::{Context, Result};
 use config::{Config, Environment, File};
 use notify::{RecommendedWatcher, RecursiveMode, Watcher};
-use std::path::Path;
-use std::sync::Arc;
 use tokio::sync::{mpsc, Mutex};
 use tracing::*;
 use warpgate_common::helpers::fs::secure_file;

warpgate/src/logging.rs

@@ -1,4 +1,5 @@
 use std::sync::Arc;
+
 use time::{format_description, UtcOffset};
 use tracing_subscriber::filter::dynamic_filter_fn;
 use tracing_subscriber::fmt::time::OffsetTime;

warpgate/src/main.rs

@@ -2,13 +2,15 @@
 mod commands;
 mod config;
 mod logging;
-use crate::config::load_config;
+use std::path::PathBuf;
+
 use anyhow::Result;
 use clap::{ArgAction, StructOpt};
 use logging::init_logging;
-use std::path::PathBuf;
 use tracing::*;
 
+use crate::config::load_config;
+
 #[cfg(feature = "dhat-heap")]
 #[global_allocator]
 static ALLOC: dhat::Alloc = dhat::Alloc;