Build tools (Maven, Gradle, npm) in Jenkins - Step-by-Step Execution

Process Flow - Build tools (Maven, Gradle, npm)

Start Build Request

↓

Select Build Tool

↓

Maven

↓

Run Build Command

↓

Compile Code & Resolve Dependencies

↓

Run Tests

↓

Package Artifacts

↓

Build Success or Failure

↓

End

The build process starts by choosing a tool (Maven, Gradle, or npm), running its commands to compile, test, and package code, then ends with success or failure.

Execution Sample

Jenkins

mvn clean install
# or
gradle build
# or
npm install && npm run build

These commands run the build process using Maven, Gradle, or npm respectively.

Process Table

Step	Build Tool	Command Run	Action	Result
1	Maven	mvn clean install	Clean previous build, compile code, run tests, package	Build success
2	Gradle	gradle build	Compile code, resolve dependencies, run tests, package	Build success
3	npm	npm install	Install dependencies from package.json	Dependencies installed
4	npm	npm run build	Run build script (e.g., transpile, bundle, run tests)	Build success
5	All	N/A	Check build status	Success or failure reported

💡 Build process ends after packaging and test results determine success or failure.

Status Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	Final
Build Status	Not started	Success (Maven)	Success (Gradle)	Dependencies installed (npm)	Success (npm build)	Success or failure

Key Moments - 3 Insights

Why do npm builds often have two commands instead of one?

npm separates installing dependencies (npm install) from running the build script (npm run build), unlike Maven or Gradle which combine steps. See execution_table rows 3 and 4.

What happens if tests fail during the build?

The build stops and reports failure at the test step, so packaging does not happen. This is implied in the 'Build success' or 'failure' result in the execution_table.

Why do Maven and Gradle commands look simpler than npm's two-step process?

Maven and Gradle commands like 'mvn clean install' or 'gradle build' combine cleaning, compiling, testing, and packaging in one command, while npm splits install and build scripts.

Visual Quiz - 3 Questions

Look at the execution table, what is the result after running 'npm install'?

A Build success

B Tests run

C Dependencies installed

D Packaging complete

💡 Hint

Check execution_table row 3 under 'Result' column.

At which step does the build tool run tests?

A Step 1 and 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look at the 'Action' column in execution_table rows 1 and 2 mentioning 'run tests'.

If tests fail during Maven build, what happens next?

A Build continues to packaging

B Build stops and reports failure

C Dependencies reinstall automatically

D npm commands run next

💡 Hint

Refer to key_moments about test failure stopping the build.

Concept Snapshot

Build tools automate compiling, testing, and packaging code.
Maven and Gradle use single commands like 'mvn clean install' or 'gradle build'.
npm separates dependency install ('npm install') and build ('npm run build').
Build success depends on passing tests and packaging.
Failures stop the build early.

Full Transcript

Build tools like Maven, Gradle, and npm help automate software building. The process starts by selecting a tool and running its build commands. Maven and Gradle combine cleaning, compiling, testing, and packaging in one command. npm splits installing dependencies and running build scripts into two commands. The build runs tests and packages the code. If tests fail, the build stops and reports failure. Success means the code is compiled, tested, and packaged correctly.

Practice

1. What is the primary purpose of build tools like Maven, Gradle, and npm in Jenkins pipelines?

easy

A. To automate compiling, testing, and packaging code

B. To write application code manually

C. To deploy applications to production servers

D. To monitor server health and uptime

Solution

1. Step 1: Understand build tools' role

   Build tools automate tasks like compiling code, running tests, and packaging software.

2. Step 2: Connect with Jenkins pipeline usage

   Jenkins pipelines use these tools to automate software delivery steps efficiently.

3. Final Answer:

   To automate compiling, testing, and packaging code -> Option A

4. Quick Check:

   Build tools automate build tasks = D [OK]

Hint: Build tools automate code build and test steps [OK]

Common Mistakes:

• Confusing build tools with deployment tools
• Thinking build tools write code
• Mixing monitoring tools with build tools

2. Which of the following is the correct Jenkins pipeline syntax to run a Maven build command?

easy

A. sh 'gradle build'

B. bat 'npm install'

C. bat 'mvn deploy'

D. sh 'mvn clean install'

Solution

1. Step 1: Identify the shell command for Maven

   Maven commands run in shell using sh 'mvn ...' in Jenkins on Linux agents.

2. Step 2: Match the correct Maven build command

   mvn clean install compiles and packages the project.

3. Final Answer:

   sh 'mvn clean install' -> Option D

4. Quick Check:

   Maven build command in shell = C [OK]

Hint: Use sh 'mvn clean install' for Maven builds on Linux [OK]

Common Mistakes:

• Using npm or gradle commands for Maven builds
• Using bat instead of sh on Linux agents
• Confusing deploy with build commands

3. Given this Jenkins pipeline snippet, what will be the output if the npm install command fails?

pipeline {
  agent any
  stages {
    stage('Install') {
      steps {
        sh 'npm install'
      }
    }
  }
}

medium

A. Pipeline continues to next stage ignoring failure

B. Pipeline stops and marks build as failed

C. Pipeline retries npm install automatically

D. Pipeline marks build as unstable but continues

Solution

1. Step 1: Understand default Jenkins shell step behavior

   By default, if sh command fails, Jenkins stops the pipeline and marks build as failed.

2. Step 2: Apply this to npm install failure

   If npm install fails, the pipeline will stop immediately and fail.

3. Final Answer:

   Pipeline stops and marks build as failed -> Option B

4. Quick Check:

   Failed shell command stops pipeline = A [OK]

Hint: Failed shell commands stop Jenkins pipeline by default [OK]

Common Mistakes:

• Assuming pipeline continues after failure
• Thinking Jenkins retries commands automatically
• Confusing unstable with failed build status

4. You wrote this Jenkins pipeline step to run Gradle build but it fails with 'command not found':

sh 'gradle build'

What is the most likely cause and fix?

medium

A. Gradle is not installed or not in PATH; install Gradle or set PATH

B. Syntax error in Jenkinsfile; change to bat 'gradle build'

C. Use npm instead of Gradle for Java projects

D. Replace 'build' with 'install' in the command

Solution

1. Step 1: Analyze error 'command not found'

   This error means the system cannot find the gradle command in the PATH.

2. Step 2: Fix by installing Gradle or updating PATH

   Ensure Gradle is installed on the Jenkins agent and its bin directory is in the PATH environment variable.

3. Final Answer:

   Gradle is not installed or not in PATH; install Gradle or set PATH -> Option A

4. Quick Check:

   Command not found means missing install or PATH = A [OK]

Hint: Check PATH and install Gradle if 'command not found' error occurs [OK]

Common Mistakes:

• Using Windows bat syntax on Linux agents
• Confusing npm with Gradle for Java builds
• Changing command without fixing environment

5. You want to create a Jenkins pipeline that runs npm install, then runs tests with npm test, but only if install succeeds. Which pipeline snippet correctly implements this?

hard

A. sh 'npm install; npm test'

B. try {
sh 'npm install'
sh 'npm test'
} catch (e) {
echo 'Install failed'
}

C. sh 'npm install && npm test'

D. sh 'npm test'
sh 'npm install'

Solution

1. Step 1: Understand command chaining with &&

   Using npm install && npm test runs tests only if install succeeds.

2. Step 2: Compare with other options

   sh 'npm install; npm test' runs test regardless because ';' executes the next command irrespective of exit code. try { sh 'npm install' sh 'npm test' } catch (e) { echo 'Install failed' } uses try-catch but Jenkins declarative pipeline syntax does not support this directly. sh 'npm test' sh 'npm install' runs test before install, which is wrong order.

3. Final Answer:

   sh 'npm install && npm test' -> Option C

4. Quick Check:

   Use && to run second command only if first succeeds = B [OK]

Hint: Chain commands with && to run second only if first succeeds [OK]

Common Mistakes:

• Using ';' instead of '&&' to chain commands
• Using try-catch incorrectly in Jenkinsfile
• Running tests before installing dependencies