Fallback to syntax-check if ansible-lint is not installed or disabled

src/ansibleLanguageService.ts

@@ -143,7 +143,13 @@ export class AnsibleLanguageService {
         const context = this.workspaceManager.getContext(e.document.uri);
         if (context) {
           // perform full validation
-          await doValidate(e.document, this.validationManager, false, context);
+          await doValidate(
+            e.document,
+            this.validationManager,
+            false,
+            context,
+            this.connection
+          );
         }
       } catch (error) {
         this.handleError(error, 'onDidOpen');
@@ -177,7 +183,13 @@ export class AnsibleLanguageService {
         const context = this.workspaceManager.getContext(e.document.uri);
         if (context) {
           // perform full validation
-          await doValidate(e.document, this.validationManager, false, context);
+          await doValidate(
+            e.document,
+            this.validationManager,
+            false,
+            context,
+            this.connection
+          );
         }
       } catch (error) {
         this.handleError(error, 'onDidSave');
@@ -201,7 +213,8 @@ export class AnsibleLanguageService {
           e.document,
           this.validationManager,
           true,
-          this.workspaceManager.getContext(e.document.uri)
+          this.workspaceManager.getContext(e.document.uri),
+          this.connection
         );
       } catch (error) {
         this.handleError(error, 'onDidChangeContent');

src/providers/validationProvider.ts

@@ -1,6 +1,7 @@
 import IntervalTree from '@flatten-js/interval-tree';
 import * as _ from 'lodash';
 import {
+  Connection,
   Diagnostic,
   DiagnosticRelatedInformation,
   DiagnosticSeverity,
@@ -11,6 +12,7 @@ import { TextDocument } from 'vscode-languageserver-textdocument';
 import { ValidationManager } from '../services/validationManager';
 import { WorkspaceFolderContext } from '../services/workspaceManager';
 import { parseAllDocuments } from '../utils/yaml';
+import { getExecutablePath } from '../utils/misc';
 
 /**
  * Validates the given document.
@@ -23,7 +25,8 @@ export async function doValidate(
   textDocument: TextDocument,
   validationManager: ValidationManager,
   quick = true,
-  context?: WorkspaceFolderContext
+  context?: WorkspaceFolderContext,
+  connection?: Connection
 ): Promise<Map<string, Diagnostic[]>> {
   let diagnosticsByFile;
   if (quick || !context) {
@@ -32,8 +35,34 @@ export async function doValidate(
       validationManager.getValidationFromCache(textDocument.uri) ||
       new Map<string, Diagnostic[]>();
   } else {
-    // full validation with ansible-lint
-    diagnosticsByFile = await context.ansibleLint.doValidate(textDocument);
+    // full validation with ansible-lint or ansible syntax-check (if ansible-lint is not installed or disabled)
+
+    const settings = await context.documentSettings.get(textDocument.uri);
+
+    const lintAvailability = await getExecutablePath(settings.ansibleLint.path);
+    console.debug('Path for lint: ', lintAvailability);
+
+    if (lintAvailability) {
+      console.debug('Validating using ansible-lint');
+      diagnosticsByFile = await context.ansibleLint.doValidate(textDocument);
+    }
+
+    if (!diagnosticsByFile || !lintAvailability || diagnosticsByFile === -1) {
+      // Notifying the user about the failed ansible-lint command and falling back to ansible syntax-check in this scenario
+      if (diagnosticsByFile === -1) {
+        console.debug(
+          'Ansible-lint command execution failed. Falling back to ansible syntax-check'
+        );
+        connection.window.showInformationMessage(
+          'Falling back to ansible syntax-check.'
+        );
+      }
+      console.debug('Validating using ansible syntax-check');
+      diagnosticsByFile = await context.ansiblePlaybook.doValidate(
+        textDocument
+      );
+    }
+
     if (!diagnosticsByFile.has(textDocument.uri)) {
       // In case there are no diagnostics for the file that triggered the
       // validation, set an empty array in order to clear the validation.

src/services/ansibleLint.ts

@@ -50,14 +50,19 @@ export class AnsibleLint {
    */
   public async doValidate(
     textDocument: TextDocument
-  ): Promise<Map<string, Diagnostic[]>> {
+  ): Promise<Map<string, Diagnostic[]> | -1> {
     let diagnostics: Map<string, Diagnostic[]> = new Map();
 
     const workingDirectory = URI.parse(this.context.workspaceFolder.uri).path;
 
     const settings = await this.context.documentSettings.get(textDocument.uri);
 
-    if (settings.ansibleLint.enabled) {
+    if (!settings.ansibleLint.enabled) {
+      console.debug(
+        'Ansible-lint is disabled. Falling back to ansible syntax-check'
+      );
+      return;
+    } else {
       let linterArguments = settings.ansibleLint.arguments;
 
       // Determine linter config file
@@ -132,6 +137,7 @@ export class AnsibleLint {
             );
           } else {
             this.connection.window.showErrorMessage(execError.message);
+            return -1;
           }
 
           if (execError.stderr) {

src/services/ansiblePlaybook.ts

@@ -0,0 +1,160 @@
+import * as child_process from 'child_process';
+import { URI } from 'vscode-uri';
+import { promisify } from 'util';
+import {
+  Connection,
+  Diagnostic,
+  DiagnosticSeverity,
+  Position,
+  Range,
+} from 'vscode-languageserver';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { withInterpreter } from '../utils/misc';
+import { WorkspaceFolderContext } from './workspaceManager';
+
+const exec = promisify(child_process.exec);
+
+/**
+ * Acts as an interface to ansible-playbook command.
+ */
+export class AnsiblePlaybook {
+  private useProgressTracker = false;
+
+  /**
+   *
+   * @param connection establishes connection with the client
+   * @param context provides workspace context of the client
+   */
+
+  constructor(
+    private connection: Connection,
+    private context: WorkspaceFolderContext
+  ) {
+    this.useProgressTracker =
+      !!context.clientCapabilities.window?.workDoneProgress;
+  }
+
+  /**
+   * Acts as an interface to ansible-playbook <file> --syntax-check command and a cache of its output.
+   * ansible syntax-check may provide diagnostics for more than just the file for which
+   * it was triggered, and this is reflected in the implementation.
+   *
+   * Perform ansible syntax-check for the given document.
+   */
+  public async doValidate(
+    textDocument: TextDocument
+  ): Promise<Map<string, Diagnostic[]>> {
+    const docPath = URI.parse(textDocument.uri).path;
+    let diagnostics: Map<string, Diagnostic[]> = new Map();
+    const progressTracker = this.useProgressTracker
+      ? await this.connection.window.createWorkDoneProgress()
+      : {
+          begin: () => {}, // eslint-disable-line @typescript-eslint/no-empty-function
+          done: () => {}, // eslint-disable-line @typescript-eslint/no-empty-function
+        };
+
+    const workingDirectory = URI.parse(this.context.workspaceFolder.uri).path;
+
+    const settings = await this.context.documentSettings.get(textDocument.uri);
+
+    progressTracker.begin(
+      'ansible syntax-check',
+      undefined,
+      'Processing files...'
+    );
+
+    const [command, env] = withInterpreter(
+      `${settings.ansible.path}-playbook`,
+      `${docPath} --syntax-check`,
+      settings.python.interpreterPath,
+      settings.python.activationScript
+    );
+
+    try {
+      await exec(command, {
+        encoding: 'utf-8',
+        cwd: workingDirectory,
+        env: env,
+      });
+    } catch (error) {
+      if (error instanceof Error) {
+        const execError = error as child_process.ExecException & {
+          // according to the docs, these are always available
+          stdout: string;
+          stderr: string;
+        };
+
+        // This is the regex to extract the filename, line and column number from the strerr produced by syntax-check command
+        const ansibleSyntaxCheckRegex =
+          /The error appears to be in '(?<filename>.*)': line (?<line>\d+), column (?<column>\d+)/;
+
+        const filteredErrorMessage = ansibleSyntaxCheckRegex.exec(execError.stderr);
+
+        diagnostics = filteredErrorMessage
+          ? this.processReport(
+              execError.message,
+              filteredErrorMessage.groups.filename,
+              parseInt(filteredErrorMessage.groups.line),
+              parseInt(filteredErrorMessage.groups.column)
+            )
+          : this.processReport(execError.message, docPath, 1, 1);
+
+        if (execError.stderr) {
+          this.connection.console.info(
+            `[ansible syntax-check] ${execError.stderr}`
+          );
+        }
+      } else {
+        this.connection.console.error(
+          `Exception in AnsibleSyntaxCheck service: ${JSON.stringify(error)}`
+        );
+      }
+    }
+
+    progressTracker.done();
+    return diagnostics;
+  }
+
+  private processReport(
+    result: string,
+    fileName: string,
+    line: number,
+    column: number
+  ): Map<string, Diagnostic[]> {
+    const diagnostics: Map<string, Diagnostic[]> = new Map();
+    if (!result) {
+      this.connection.console.warn(
+        'Standard output from ansible syntax-check is suspiciously empty.'
+      );
+      return diagnostics;
+    }
+    const start: Position = {
+      line: line - 1,
+      character: column - 1,
+    };
+    const end: Position = {
+      line: line - 1,
+      character: Number.MAX_SAFE_INTEGER,
+    };
+    const range: Range = {
+      start,
+      end,
+    };
+
+    const severity: DiagnosticSeverity = DiagnosticSeverity.Error;
+
+    const locationUri = `file://${fileName}`;
+
+    const fileDiagnostics = diagnostics.get(locationUri) || [];
+
+    fileDiagnostics.push({
+      message: result,
+      range,
+      severity,
+      source: 'Ansible',
+    });
+
+    diagnostics.set(locationUri, fileDiagnostics);
+    return diagnostics;
+  }
+}

src/services/workspaceManager.ts

@@ -8,6 +8,7 @@ import {
 } from 'vscode-languageserver';
 import { AnsibleConfig } from './ansibleConfig';
 import { AnsibleLint } from './ansibleLint';
+import { AnsiblePlaybook } from './ansiblePlaybook';
 import { DocsLibrary } from './docsLibrary';
 import { ExecutionEnvironment } from './executionEnvironment';
 import { MetadataLibrary } from './metadataLibrary';
@@ -113,6 +114,7 @@ export class WorkspaceFolderContext {
   private _docsLibrary: Thenable<DocsLibrary> | undefined;
   private _ansibleConfig: Thenable<AnsibleConfig> | undefined;
   private _ansibleLint: AnsibleLint | undefined;
+  private _ansiblePlaybook: AnsiblePlaybook | undefined;
 
   constructor(
     connection: Connection,
@@ -180,6 +182,13 @@ export class WorkspaceFolderContext {
     return this._ansibleLint;
   }
 
+  public get ansiblePlaybook(): AnsiblePlaybook {
+    if (!this._ansiblePlaybook) {
+      this._ansiblePlaybook = new AnsiblePlaybook(this.connection, this);
+    }
+    return this._ansiblePlaybook;
+  }
+
   public get executionEnvironment(): Thenable<ExecutionEnvironment> {
     if (!this._executionEnvironment) {
       const executionEnvironment = new ExecutionEnvironment(

src/utils/misc.ts

@@ -81,3 +81,23 @@ export function withInterpreter(
     return [command, undefined];
   }
 }
+
+/**
+ * A method to return the path to the provided executable
+ * @param executable String representing the name of the executable
+ * @returns Complete path of the executable (string) or undefined depending updon the presence of the executable
+ */
+export async function getExecutablePath(
+  executable: string
+): Promise<string> | undefined {
+  const exec = promisify(child_process.exec);
+
+  try {
+    const executablePath = await exec(`which ${executable}`, {
+      encoding: 'utf-8',
+    });
+    return executablePath.stdout;
+  } catch (error) {
+    return;
+  }
+}