refactor(app): extract command generation logic

Author: tembleking

src/app/lsp_server/command_generator.rs

@@ -0,0 +1,90 @@
+use serde_json::{Value, json};
+use tower_lsp::lsp_types::{Location, Range, Url};
+
+use crate::app::lsp_server::supported_commands::SupportedCommands;
+use crate::infra::{parse_compose_file, parse_dockerfile};
+
+pub struct CommandInfo {
+    pub title: String,
+    pub command: String,
+    pub arguments: Option<Vec<Value>>,
+    pub range: Range,
+}
+
+impl From<SupportedCommands> for CommandInfo {
+    fn from(value: SupportedCommands) -> Self {
+        match &value {
+            SupportedCommands::ExecuteBaseImageScan { location, image } => CommandInfo {
+                title: "Scan base image".to_owned(),
+                command: value.as_string_command(),
+                arguments: Some(vec![json!(location), json!(image)]),
+                range: location.range,
+            },
+
+            SupportedCommands::ExecuteBuildAndScan { location } => CommandInfo {
+                title: "Build and scan".to_owned(),
+                command: value.as_string_command(),
+                arguments: Some(vec![json!(location)]),
+                range: location.range,
+            },
+        }
+    }
+}
+
+pub fn generate_commands_for_uri(uri: &Url, content: &str) -> Vec<CommandInfo> {
+    let file_uri = uri.as_str();
+
+    if file_uri.contains("docker-compose.yml")
+        || file_uri.contains("compose.yml")
+        || file_uri.contains("docker-compose.yaml")
+        || file_uri.contains("compose.yaml")
+    {
+        generate_compose_commands(uri, content)
+    } else {
+        generate_dockerfile_commands(uri, content)
+    }
+}
+
+fn generate_compose_commands(url: &Url, content: &str) -> Vec<CommandInfo> {
+    let mut commands = vec![];
+    if let Ok(instructions) = parse_compose_file(content) {
+        for instruction in instructions {
+            commands.push(
+                SupportedCommands::ExecuteBaseImageScan {
+                    location: Location::new(url.clone(), instruction.range),
+                    image: instruction.image_name,
+                }
+                .into(),
+            );
+        }
+    }
+    commands
+}
+
+fn generate_dockerfile_commands(uri: &Url, content: &str) -> Vec<CommandInfo> {
+    let mut commands = vec![];
+    let instructions = parse_dockerfile(content);
+    if let Some(last_from_instruction) = instructions
+        .iter()
+        .filter(|instruction| instruction.keyword == "FROM")
+        .next_back()
+    {
+        let range = last_from_instruction.range;
+        commands.push(
+            SupportedCommands::ExecuteBuildAndScan {
+                location: Location::new(uri.clone(), range),
+            }
+            .into(),
+        );
+        if let Some(image) = last_from_instruction.arguments.first() {
+            commands.push(
+                SupportedCommands::ExecuteBaseImageScan {
+                    location: Location::new(uri.clone(), range),
+                    image: image.to_owned(),
+                }
+                .into(),
+            );
+        }
+    }
+    commands
+}

src/app/lsp_server/lsp_server_inner.rs

@@ -0,0 +1,275 @@
+use std::path::PathBuf;
+use std::str::FromStr;
+
+use serde_json::Value;
+use tower_lsp::jsonrpc::{Error, ErrorCode, Result};
+use tower_lsp::lsp_types::{
+    CodeActionOrCommand, CodeActionParams, CodeActionProviderCapability, CodeActionResponse,
+    CodeLens, CodeLensOptions, CodeLensParams, Command, DidChangeConfigurationParams,
+    DidChangeTextDocumentParams, DidOpenTextDocumentParams, ExecuteCommandOptions,
+    ExecuteCommandParams, InitializeParams, InitializeResult, InitializedParams, MessageType,
+    Range, ServerCapabilities, TextDocumentSyncCapability, TextDocumentSyncKind,
+};
+use tracing::{debug, info};
+
+use super::super::commands::CommandExecutor;
+use super::super::component_factory::{ComponentFactory, Config};
+use super::super::queries::QueryExecutor;
+use super::command_generator;
+use super::{InMemoryDocumentDatabase, LSPClient, WithContext};
+
+use super::supported_commands::SupportedCommands;
+
+pub struct LSPServerInner<C> {
+    command_executor: CommandExecutor<C>,
+    query_executor: QueryExecutor,
+    component_factory: ComponentFactory,
+}
+
+impl<C> LSPServerInner<C> {
+    pub fn new(client: C) -> LSPServerInner<C> {
+        let document_database = InMemoryDocumentDatabase::default();
+
+        LSPServerInner {
+            command_executor: CommandExecutor::new(client, document_database.clone()),
+            query_executor: QueryExecutor::new(document_database.clone()),
+            component_factory: Default::default(), // to be initialized in the initialize method of the LSP
+        }
+    }
+}
+
+impl<C> LSPServerInner<C>
+where
+    C: LSPClient + Send + Sync + 'static,
+{
+    async fn initialize_component_factory_with(&mut self, config: &Value) -> Result<()> {
+        let Ok(config) = serde_json::from_value::<Config>(config.clone()) else {
+            return Err(Error::internal_error()
+                .with_message(format!("unable to transform json into config: {config}")));
+        };
+
+        debug!("updating with configuration: {config:?}");
+
+        self.component_factory.initialize_with(config);
+
+        debug!("updated configuration");
+        Ok(())
+    }
+}
+
+impl<C> LSPServerInner<C>
+where
+    C: LSPClient + Send + Sync + 'static,
+{
+    pub async fn initialize(
+        &mut self,
+        initialize_params: InitializeParams,
+    ) -> Result<InitializeResult> {
+        let Some(config) = initialize_params.initialization_options else {
+            return Err(Error {
+                code: ErrorCode::InvalidParams,
+                message: "expected parameters to configure the LSP, received nothing".into(),
+                data: None,
+            });
+        };
+
+        self.initialize_component_factory_with(&config).await?;
+
+        Ok(InitializeResult {
+            capabilities: ServerCapabilities {
+                text_document_sync: Some(TextDocumentSyncCapability::Kind(
+                    TextDocumentSyncKind::FULL,
+                )),
+                code_action_provider: Some(CodeActionProviderCapability::Simple(true)),
+                code_lens_provider: Some(CodeLensOptions {
+                    resolve_provider: Some(false),
+                }),
+                execute_command_provider: Some(ExecuteCommandOptions {
+                    commands: SupportedCommands::all_supported_commands_as_string(),
+                    ..Default::default()
+                }),
+                ..Default::default()
+            },
+            ..Default::default()
+        })
+    }
+
+    pub async fn initialized(&self, _: InitializedParams) {
+        info!("Initialized");
+        self.command_executor
+            .show_message(MessageType::INFO, "Sysdig LSP initialized")
+            .await;
+    }
+
+    pub async fn did_change_configuration(&mut self, params: DidChangeConfigurationParams) {
+        let _ = self
+            .initialize_component_factory_with(&params.settings)
+            .await;
+    }
+
+    pub async fn did_open(&self, params: DidOpenTextDocumentParams) {
+        self.command_executor
+            .update_document_with_text(
+                params.text_document.uri.as_str(),
+                params.text_document.text.as_str(),
+            )
+            .await;
+    }
+
+    pub async fn did_change(&self, params: DidChangeTextDocumentParams) {
+        if let Some(change) = params.content_changes.into_iter().next_back() {
+            self.command_executor
+                .update_document_with_text(params.text_document.uri.as_str(), &change.text)
+                .await;
+        }
+    }
+
+    pub async fn code_action(
+        &self,
+        params: CodeActionParams,
+    ) -> Result<Option<CodeActionResponse>> {
+        let Some(content) = self
+            .query_executor
+            .get_document_text(params.text_document.uri.as_str())
+            .await
+        else {
+            return Err(Error::internal_error().with_message(format!(
+                "unable to extract document content for document: {}",
+                &params.text_document.uri
+            )));
+        };
+
+        let commands =
+            command_generator::generate_commands_for_uri(&params.text_document.uri, &content);
+        let code_actions: Vec<CodeActionOrCommand> = commands
+            .into_iter()
+            .filter(|cmd| cmd.range.start.line == params.range.start.line)
+            .map(|cmd| {
+                CodeActionOrCommand::Command(Command {
+                    title: cmd.title,
+                    command: cmd.command,
+                    arguments: cmd.arguments,
+                })
+            })
+            .collect();
+
+        Ok(Some(code_actions))
+    }
+
+    pub async fn code_lens(&self, params: CodeLensParams) -> Result<Option<Vec<CodeLens>>> {
+        let Some(content) = self
+            .query_executor
+            .get_document_text(params.text_document.uri.as_str())
+            .await
+        else {
+            return Err(Error::internal_error().with_message(format!(
+                "unable to extract document content for document: {}",
+                &params.text_document.uri
+            )));
+        };
+
+        let commands =
+            command_generator::generate_commands_for_uri(&params.text_document.uri, &content);
+        let code_lenses = commands
+            .into_iter()
+            .map(|cmd| CodeLens {
+                range: cmd.range,
+                command: Some(Command {
+                    title: cmd.title,
+                    command: cmd.command,
+                    arguments: cmd.arguments,
+                }),
+                data: None,
+            })
+            .collect();
+
+        Ok(Some(code_lenses))
+    }
+
+    pub async fn execute_command(&mut self, params: ExecuteCommandParams) -> Result<Option<Value>> {
+        let command: SupportedCommands = params.try_into()?;
+
+        let result = match command.clone() {
+            SupportedCommands::ExecuteBaseImageScan { location, image } => {
+                execute_command_scan_base_image(
+                    self,
+                    location.uri.to_string(),
+                    location.range,
+                    image,
+                )
+                .await
+                .map(|_| None)
+            }
+
+            SupportedCommands::ExecuteBuildAndScan { location } => {
+                execute_command_build_and_scan(self, location.uri.to_string(), location.range)
+                    .await
+                    .map(|_| None)
+            }
+        };
+
+        match result {
+            Ok(_) => result,
+            Err(mut e) => {
+                self.command_executor
+                    .show_message(MessageType::ERROR, e.to_string().as_str())
+                    .await;
+                e.message = format!("error calling command: '{command}': {e}").into();
+                Err(e)
+            }
+        }
+    }
+
+    pub async fn shutdown(&self) -> Result<()> {
+        Ok(())
+    }
+}
+
+async fn execute_command_scan_base_image<C: LSPClient>(
+    server: &mut LSPServerInner<C>,
+    file: String,
+    range: Range,
+    image: String,
+) -> Result<()> {
+    let image_scanner = {
+        server.component_factory.image_scanner().map_err(|e| {
+            Error::internal_error().with_message(format!("unable to create image scanner: {e}"))
+        })?
+    };
+
+    server
+        .command_executor
+        .scan_image(&file, range, &image, &image_scanner)
+        .await?;
+
+    Ok(())
+}
+
+async fn execute_command_build_and_scan<C: LSPClient>(
+    server: &mut LSPServerInner<C>,
+    file: String,
+    range: Range,
+) -> Result<()> {
+    let (image_scanner, image_builder) = {
+        let image_scanner = server.component_factory.image_scanner().map_err(|e| {
+            Error::internal_error().with_message(format!("unable to create image scanner: {e}"))
+        })?;
+        let image_builder = server.component_factory.image_builder().map_err(|e| {
+            Error::internal_error().with_message(format!("unable to create image builder: {e}"))
+        })?;
+
+        (image_scanner, image_builder)
+    };
+
+    server
+        .command_executor
+        .build_and_scan_from_file(
+            &PathBuf::from_str(&file).unwrap(),
+            range.start.line,
+            &image_builder,
+            &image_scanner,
+        )
+        .await?;
+
+    Ok(())
+}