CLI Archives - scmGalaxy

Understanding Command-Line: Use Cases, Architecture, and Getting Started Guide

Vijay K — Sat, 14 Jun 2025 12:20:00 +0000

What is Command-Line?

The command-line refers to a text-based interface used to interact with a computer’s operating system or software by typing commands. It is an alternative to graphical user interfaces (GUIs), where users interact with the system via icons, buttons, and menus. The command-line interface (CLI) allows users to input commands directly, providing a way to perform tasks and execute programs.

The command-line is usually accessed through a terminal or shell, which is a program that processes user commands. Popular examples of command-line interfaces include Bash (used in Linux and macOS), Command Prompt (Windows), and PowerShell (Windows). These interfaces interpret the user’s typed commands and communicate with the operating system to perform the desired actions, such as file management, system configuration, or running programs.

Key Features of Command-Line:

Text-based Input and Output: Users type text commands, and the system responds with text output.
Power and Flexibility: The command-line provides direct access to system functions, often with greater flexibility and power than a GUI.
Automation: The command-line is ideal for automating repetitive tasks with scripts or batch files.
System Interaction: It allows low-level interaction with the operating system, enabling users to modify system configurations, manage files, and control running processes.

The command-line is favored by system administrators, developers, and power users for its efficiency, speed, and ability to handle complex tasks in a streamlined manner.

What are the Major Use Cases of Command-Line?

The command-line interface (CLI) has been a core tool in system administration, software development, and automation for many years. Here are some of the major use cases of the command-line:

1. System Administration

System administrators use the CLI to manage and configure computer systems. With the command-line, they can perform tasks like:

File management (copying, moving, deleting files, and directories).
Process management (monitoring and controlling running processes).
Network configuration (setting up network interfaces, checking connectivity).
User management (creating, modifying, or deleting users).

For example, on Linux systems, commands like ls, cp, ps, and useradd allow admins to manage files, monitor processes, and create new users.

2. Automation and Scripting

The command-line is often used to automate tasks through shell scripting. Scripts are collections of commands that can be executed in sequence. This allows repetitive tasks to be automated, improving efficiency.

Bash scripting (for Linux/macOS) and batch scripting (for Windows) allow users to write scripts for file backups, software installation, system updates, and more.

For example, a simple Bash script to backup files could look like this:

#!/bin/bash
cp -r /home/user/data /backup/location

3. Development and Debugging

Developers frequently use the CLI to run compilers, build tools, version control systems, and debuggers. Tools like Git, Docker, npm, and make are all accessed through the command-line interface.

Git is a distributed version control system, and commands like git commit, git pull, and git push are run through the command-line to manage code repositories.
Docker allows developers to build, run, and manage containers using commands such as docker build and docker run.

4. Remote System Access

The command-line is often used to interact with remote systems, especially for managing servers or cloud infrastructure. Tools like SSH (Secure Shell) allow users to connect to and control remote servers through the CLI.

Administrators can use the ssh command to access a server and perform tasks remotely:

ssh user@remote-server-ip

5. Package Management and Software Installation

Most operating systems provide package management tools that allow users to install, update, and remove software via the command-line.

On Linux, tools like apt (for Debian-based systems) and yum (for Red Hat-based systems) are commonly used:

sudo apt install package-name

On macOS, Homebrew is a popular package manager accessed via the terminal.

6. Text Processing

The command-line is commonly used to manipulate text files. Tools like grep, awk, sed, and sort allow users to search, filter, modify, and sort large text files efficiently.

For example:

grep is used to search for patterns within files:

grep "search_term" file.txt

7. Networking and Connectivity

The CLI is essential for troubleshooting network issues, managing network services, and testing network connections. Commands like ping, ifconfig, netstat, and curl are used to manage and test network settings.

For example:

ping checks connectivity to a remote server:

ping google.com

How Command-Line Works Along with Architecture?

The command-line operates within the architecture of an operating system. The basic flow of how the command-line works involves interaction with the operating system through shells, processes, and commands.

1. Shells and Command Interpreters

The command-line interface is provided by shells, which are programs that interpret the user’s commands and send them to the operating system. Popular shells include:

Bash (Bourne Again Shell) – commonly used in Linux and macOS.
PowerShell – used in Windows for more advanced scripting and management.
Command Prompt – the traditional CLI for Windows.

The shell reads the input from the user, interprets the command, and passes it to the operating system for execution.

2. Processes and Task Management

Once a command is entered in the command-line interface, it is translated into a process that is executed by the operating system. The operating system manages the process lifecycle, which includes:

Launching the Process: When a user runs a command, the shell creates a process and assigns resources to it (CPU time, memory).
Managing Execution: The operating system manages the execution of the process, allocating resources and handling system calls.
Process Termination: After the command completes its task, the process terminates, and the operating system frees up resources.

3. File System Interaction

When commands are executed, they often interact with the file system to access, modify, or manage files. For example:

File management commands: ls, cd, cp, mv are used to navigate and manipulate files.
Piping and Redirection: Outputs from one command can be redirected to files or passed as input to other commands. This allows for efficient data manipulation using a sequence of commands.

For example, ls | grep "example" lists all files and filters the output using grep to search for the term “example”.

4. Environment Variables and Configurations

The shell also makes use of environment variables that store system-wide or user-specific configuration settings. These variables control the behavior of the operating system and applications.

Examples: PATH, HOME, USER, and SHELL.

Basic Workflow of Command-Line

The basic workflow of using the command-line interface involves several steps to execute tasks. Here’s a typical sequence of actions in a command-line-based workflow:

Open the Terminal or Command Prompt
- On Linux/macOS, open a terminal emulator like GNOME Terminal or iTerm.
- On Windows, open Command Prompt or PowerShell.
Enter Commands
- Type a command into the terminal window. This can be a file operation, network request, system configuration, or software management command.
- For example: ls -l
- This lists files in the current directory in long format.
Execute the Command
- Press Enter to execute the command. The system processes the command, interacts with the underlying resources (files, processes, network), and displays the results.
View Output
- The output from the command is displayed in the terminal. This can be text output, error messages, or results.
Chain Commands (Piping and Redirection)
- You can combine multiple commands using pipes (|) and redirection (>, >>). For example: ps aux | grep "myapp"
- This command lists all running processes and filters them to find “myapp”.
Use Scripts for Automation
- To automate tasks, create scripts that contain a series of commands. Save the script as a .sh (Linux/macOS) or .bat (Windows) file and run it directly in the terminal.
Exit the Terminal
- When you’re done, type exit or press the close button to exit the terminal or command prompt.

Step-by-Step Getting Started Guide for Command-Line

To get started with the command-line interface, follow these steps:

Step 1: Access the Command-Line

Linux/macOS: Open the terminal application.
Windows: Open Command Prompt or PowerShell.

Step 2: Learn Basic Commands

Begin by learning some basic commands:

Linux/macOS:
- ls: List files in the current directory.
- cd: Change the directory.
- pwd: Print the working directory.
- cp: Copy files.
- rm: Remove files.
Windows:
- dir: List files in the directory.
- cd: Change the directory.
- cls: Clear the screen.
- copy: Copy files.
- del: Delete files.

Step 3: Navigate the File System

Use commands like cd to navigate through directories and ls (Linux/macOS) or dir (Windows) to list the contents of directories.

Step 4: Run a Simple Command

Try a simple command, such as listing the files in the current directory:

ls

Step 5: Experiment with File Operations

Try creating, moving, or deleting files using commands like touch, mv, rm (Linux/macOS) or echo, move, del (Windows).

Step 6: Write a Script

Create a simple shell script (Linux/macOS) or batch script (Windows) to automate a series of commands. Save the script with .sh (Linux/macOS) or .bat (Windows) and run it.

Example script for Linux/macOS:

#!/bin/bash
echo "Hello, World!"

Step 7: Explore Advanced Features

Once you’re comfortable with basic commands, explore more advanced features such as:

Piping and redirection.
Background processes.
Environment variables.

The command-line is a powerful tool for interacting with your system, automating tasks, and gaining deeper control over your environment. Mastering the CLI will enhance your ability to perform complex tasks quickly and efficiently, making you more proficient as a developer, system administrator, or power user.

The post Understanding Command-Line: Use Cases, Architecture, and Getting Started Guide appeared first on scmGalaxy.

Complete guide to use Jenkins CLI / Command line | Jenkins Tutorials

scmgalaxy K — Sun, 08 Jan 2017 08:37:19 +0000

Complete guide to use Jenkins CLI / Command line?

Run Jenkins build from command is very simple in Linux system. If you are using using windows, gitbash is a recommended which has bash shell in built. You can use windows command line as well. Jenkins has support to command line client that allows you to access Jenkins from command line.

To Trigger Jenkins build from command line some prerequisite are there

Jenkins service is running.

Enable security option under “Configure Global Security”

Go to jenkins dashboard in Home page ( e.g http://localhost:8080/ ) -> Manage Jenkins

-> Configure Global Security -> Click on “Enable security” checkbox

You can also configure “Access Control” and “Authorization” option in Global Security page.

Download Jenkins-cli.jar

Download Jenkins-cli.jar from http:///jnlpJars/jenkins-cli.jar. (Here is your respective Jenkins server URL (development or staging))

Go to http:///cli and build your command by following the instructions there.

How to login to Jenkins using commands

If your Jenkins requires authentication, use –username and –password or –password-file options to specify the credentials. To avoid doing this for every command, you can also use the login CLI command once (with the same credentials parameters), and after that you may use other commands without specifying credentials.

Whenever the CLI tries to to connect to the Jenkins server, it offers the before mentioned SSH keys. When the user has those keys but don’t want use them to authenticate, preventing being prompted by the key’s password, it’s possible to use the -noKeyAuth argument. This way the CLI will never try to use the SSH keys available. failure to authenticate by itself does not constitute a fatal error. It will instead try to execute the command anyway, as the anonymous user.

Login Jenkins using username and Password

Jenkins allow us to trigger Jenkins build with any specific user, For that we have to pass username and password in command line.

$ java -jar “/tmp/kitchen/cache/jenkins-cli.jar” -s http://localhost:8080 who-am-i –username jenkins –password foobar

$ java -jar jenkins-cli.jar -s http://myjenkins help –username me –password mypassword

Login Jenkins using public keys

Starting 1.419 (which will be out July 4th), Jenkins CLI supports authentication based on the SSH key pair. Just like CloudBees DEV@cloud (or GitHub, or other similar sites), you interactively login from the web UI, then associate your public keys with your user account. Then CLI will silently authenticates itself using your ~/.ssh/id_rsa, ~/.ssh/id_dsa, or ~/.ssh/identity.

https://help.github.com/articles/generating-an-ssh-key/

Login Jenkins using private keys

You can also pass the priate key as follows

To use the -i option the syntax is as follows:

$ java -jar jenkins-cli.jar -s http://myjenkins help -i ~/.ssh/id_rsa

$ java -jar jenkins-cli.jar [-s JENKINS_URL] [-i PRIVATE_KEY] command [options…] [arguments…]

For compatibility reasons, unless you use the -i option,

Login Jenkins using initialAdminPassword

try user “admin” and password from “Jenkins\secrets\initialAdminPassword”

java -jar jenkins-cli.jar -s http://localhost:8080 who-am-i –username admin –password fe3f1e1624ea4be8873b7a35e28b24be

Login Jenkins using passphrase

Go to http://jenkins-serer:8085/user/admin/configure and set the passphrase in “SSH Public Keys” and use the same passphrase with jenkins commands.

E.g 1 – Getting help

The list of the available commands depends on the server you are talking to. Visit https://jenkins.example.com/cli or use ‘help’ command to list them all:

> java -jar jenkins-cli.jar -s https://jenkins.example.com help [command]

E.g 2 – Run Jenkins Build From Command Line

> java -jar jenkins-cli.jar -s http:/// build build-name [-c] [-f] [-p] [-r N] [-s] [-v] [-w]

build-name : Name of the job to build

-c : Check for SCM changes before starting the build, and if there’s no change, exit without doing a build

-f : Follow the build progress. Like -s only interrupts are not passed through to the build.

-p : Specify the build parameters in the key=value format.

-s : Wait until the completion/abortion of the command. Interrupts are passed through to the build.

-v : Prints out the console output of the build. Use with -s

-w : Wait until the start of the command

Example – java -jar jenkins-cli.jar -s http://localhost:8080/ build ‘my-project-build’ –username roop –password roop

E.g 3 – List all jobs under the view: tools

$ java -jar jenkins-cli.jar -s http://jenkins/ list-jobs tools

E.g 4 – Get the configuration of the job: template

$ java -jar jenkins-cli.jar -s http://jenkins/ get-job template > template.xml

E.g 5 – Create a new job based on the configuration

$ java -jar jenkins-cli.jar -s http://jenkins/ create-job new_job_name < new_job_name.xml

E.g 6 – Run groovy script

$ java -jar jenkins-cli.jar -s http://jenkins/ groovy scripts/add_job_to_view.groovy

If there are any parameters in the script, just as:

import jenkins.model.*

if (args.length != 2 ) {

println “Error on arguments!”

}

def jobName = args[0] ?: ‘a_job’

def viewName = args[1] ?: ‘a_view’

println jobName + ‘ ‘ + viewName

def v = Jenkins.instance.getView(viewName)

def i = Jenkins.instance.getItemByFullName(jobName)

if (v && i) {

v.add(i)

}

pass the parameters as:

$ java -jar jenkins-cli.jar -s http://jenkins/ groovy scripts/add_job_to_view.groovy JOB_NAME VIEM_NAME

E.g 7 – Build a job

$ java -jar jenkins-cli.jar -s http://jenkins/ build new_job_name

E.g 8 – Diable a job

$ java -jar jenkins-cli.jar -s http://jenkins/ disable-job new_job_name

E.g 8 – Passing parameters when triggering a job build

Job parameters are a very handy concept. Perhaps you’ve only ever used Jenkins or another CI system to automatically run builds when a remote SCM/git repo changes. You can also trigger builds manually from within Jenkins. And whilst you’re doing that, your job can prompt for parameters to the build.

For example, we have a job named similar to “Deploy XYZ App”. It has the git repo hardcoded in the job like a normal build, but when you press “Build”, it shows a list of options: string fields, drop-down lists, etc.

When the job runs, you can use these values anywhere within your job’s configuration. Its very cool.

But how to pass those same parameters via the CLI? You use the -p key=value flag for each parameter you want to pass.

So our finished product might look like:

$ java -jar jenkins-cli.jar -s http://myjenkins build ‘Deploy XYZ App’ -i ~/.ssh/id_rsa -s -v -p target_env=api.cloudfoundry.com -p branch=master

Commons problems

Operation timed out

$ java -jar jenkins-cli.jar -s YOUR_SERVER_URL help

Exception in thread “main” java.net.ConnectException: Operation timed out

at java.net.PlainSocketImpl.socketConnect(Native Method)

at java.net.PlainSocketImpl.doConnect(PlainSocketImpl.java:351)

at java.net.PlainSocketImpl.connectToAddress(PlainSocketImpl.java:213)

at java.net.PlainSocketImpl.connect(PlainSocketImpl.java:200)

at java.net.SocksSocketImpl.connect(SocksSocketImpl.java:432)

at java.net.Socket.connect(Socket.java:529)

at java.net.Socket.connect(Socket.java:478)

at java.net.Socket.(Socket.java:375)

at java.net.Socket.(Socket.java:189)

at hudson.cli.CLI.(CLI.java:97)

at hudson.cli.CLI.(CLI.java:82)

at hudson.cli.CLI._main(CLI.java:250)

at hudson.cli.CLI.main(CLI.java:199)

Check that the JNLP port is opened if you are using a firewall on your server. You can configure its value in Jenkins configuration. By default it is set to use a random port.

java.io.IOException: No X-Jenkins-CLI2-Port

java.io.IOException: No X-Jenkins-CLI2-Port among [X-Jenkins, null, Server, X-Content-Type-Options, Connection, X-You-Are-In-Group, X-Hudson, X-Permission-Implied-By, Date, X-Jenkins-Session, X-You-Are-Authenticated-As, X-Required-Permission, Set-Cookie, Expires, Content-Length, Content-Type]

at hudson.cli.CLI.getCliTcpPort(CLI.java:284)

at hudson.cli.CLI.(CLI.java:128)

at hudson.cli.CLIConnectionFactory.connect(CLIConnectionFactory.java:72)

at hudson.cli.CLI._main(CLI.java:473)

at hudson.cli.CLI.main(CLI.java:384)

Suppressed: java.io.IOException: Server returned HTTP response code: 403 for URL: http://citest.gce.px/cli

at sun.net.www.protocol.http.HttpURLConnection.getInputStream0(HttpURLConnection.java:1840)

at sun.net.www.protocol.http.HttpURLConnection.getInputStream(HttpURLConnection.java:1441)

at hudson.cli.FullDuplexHttpStream.(FullDuplexHttpStream.java:78)

at hudson.cli.CLI.connectViaHttp(CLI.java:152)

at hudson.cli.CLI.(CLI.java:132)

… 3 more

Solution: Go to Manage Jenkins -> Configure Global Security -> “TCP port for JNLP agents”: choose fixed or random

Reference

https://wiki.jenkins-ci.org/display/JENKINS/Jenkins+CLI

http://lifuzu.com/blog/2014/04/24/playing-with-jenkins-create-job/

The post Complete guide to use Jenkins CLI / Command line | Jenkins Tutorials appeared first on scmGalaxy.

Docker Command line Reference | Docker Tutorial | Docker Guide

scmgalaxy K — Fri, 15 Jul 2016 17:50:41 +0000

One liner to stop all of Docker containers:

> docker stop $(docker ps -a -q)

One liner to remove all of Docker containers:

> docker rm $(docker ps -a -q)

> docker rm $(docker images -q)

> docker rmi $(docker images -q)

In case of error message Get http:///var/run/docker.sock/v1.14/containers/json?all=1: dial unix /var/run/docker.sock: permission denied

> sudo docker rm $(sudo docker ps -a -q)

To only stop exited containers and delete only non-tagged images.:

> docker ps –filter ‘status=Exited’ -a | xargs docker stop

> docker images –filter “dangling=true” -q | xargs docker rmi

Remove all containers that aren’t currently running:

> docker rm $(docker ps -a -q -f “status=exited*”)

if not the volumes will not be delete !!! (like if you are using a mysql docker image) and all the volumes will be orphans !

> sudo docker rm -f -v $(sudo docker ps -a -q)

The post Docker Command line Reference | Docker Tutorial | Docker Guide appeared first on scmGalaxy.

Know About Jenkins CLI | Jenkins CLI Guide

scmgalaxy K — Mon, 10 Feb 2014 04:16:10 +0000

Running CLI
java -jar jenkins-cli.jar [-s JENKINS_URL] command [options…] [arguments…]

Getting help
java -jar jenkins-cli.jar -s yourserver.com help [command]

How to download jenkins-cli.jar?
The best place to download the Jenkins CLI jar is from your own Jenkins server. This means you’ll have the matching CLI version. Visit the /cli endpoint, such as http://yourserver.com/cli, and it will give you a link to download the jar (the /jnlpJars/jenkins-cli.jar endpoint). Download that jar.

Running commands against a secure Jenkins (basic auth or ssh keys)

If your Jenkins is secured, and it probably is so that you control who can create jobs, run jobs, view results, then the command above may fail and ask for credentials.
You have two options: provide –username & –password options to every command or provide -i option and provide the path to the ssh private key that matches the public key you provided to your user account.
For example:

$ java -jar jenkins-cli.jar -s http://myjenkins help –username me –password mypassword
$ java -jar jenkins-cli.jar -s http://myjenkins help -i ~/.ssh/id_rsa

Passing parameters when triggering a job build
To pass those same parameters via the CLI? You use the -p key=value flag for each parameter you want to pass.

So our finished product might look like:

$ java -jar jenkins-cli.jar -s http://myjenkins build ‘Deploy XYZ App’ -i ~/.ssh/id_rsa -s -v -p target_env=api.cloudfoundry.com -p branch=master

How to get all commands for Jenkins CLI-
Run > http://yourserver.com/cli

java -jar jenkins-cli.jar -s http://fmsscm.corp.intuit.net/qbo-qa/ help

Available Commands

build: Builds a job, and optionally waits until its completion.
cancel-quiet-down: Cancel the effect of the “quiet-down” command.
clear-queue: Clears the build queue
connect-node: Reconnect to a node
console: Retrieves console output of a build
copy-job: Copies a job.
create-job: Creates a new job by reading stdin as a configuration XML file.
create-node: Creates a new node by reading stdin as a XML configuration.
delete-builds: Deletes build record(s).
delete-job: Deletes a job
delete-node: Deletes a node
disable-job: Disables a job
disconnect-node: Disconnects from a node
enable-job: Enables a job
get-job: Dumps the job definition XML to stdout
get-node: Dumps the node definition XML to stdout
groovy: Executes the specified Groovy script.
groovysh: Runs an interactive groovy shell.
help: Lists all the available commands.
install-plugin: Installs a plugin either from a file, an URL, or from update center.
install-tool: Performs automatic tool installation, and print its location to stdout. Can be only called from inside a build.
keep-build: Mark the build to keep the build forever.
list-changes: Dumps the changelog for the specified build(s).
list-jobs: Lists all jobs in a specific view or item group.
list-plugins: Outputs a list of installed plugins.
login: Saves the current credential to allow future commands to run without explicit credential information.
logout: Deletes the credential stored with the login command.
mail: Reads stdin and sends that out as an e-mail.
offline-node: Stop using a node for performing builds temporarily, until the next “online-node” command.
online-node: Resume using a node for performing builds, to cancel out the earlier “offline-node” command.
quiet-down: Quiet down Jenkins, in preparation for a restart. Don’t start any builds.
reload-configuration: Discard all the loaded data in memory and reload everything from file system. Useful when you modified config files directly on disk.
restart: Restart Jenkins
safe-restart: Safely restart Jenkins
safe-shutdown: Puts Jenkins into the quiet mode, wait for existing builds to be completed, and then shut down Jenkins.
session-id: Outputs the session ID, which changes every time Jenkins restarts
set-build-description: Sets the description of a build.
set-build-display-name: Sets the displayName of a build
set-build-parameter: Update/set the build parameter of the current build in progress
set-build-result: Sets the result of the current build. Works only if invoked from within a build.
set-external-build-result: Set external monitor job result.
set-next-build-number: Set build number to be used for next build.
shutdown: Immediately shuts down Jenkins server
update-job: Updates the job definition XML from stdin. The opposite of the get-job command
update-node: Updates the node definition XML from stdin. The opposite of the get-node command
version: Outputs the current version.
wait-node-offline: Wait for a node to become offline
wait-node-online: Wait for a node to become online
who-am-i: Reports your credential and permissions

Reference –
https://wiki.jenkins-ci.org/display/JENKINS/Jenkins+CLI
http://stackoverflow.com/questions/18199355/jenkins-cli-authentication
http://stackoverflow.com/questions/16617232/jenkins-cli-public-key-authentication-where-to-put-my-public-key-in-jenkins

The post Know About Jenkins CLI | Jenkins CLI Guide appeared first on scmGalaxy.

Understand Jenkins CLI | Jenkins CLI Reference

scmgalaxy K — Mon, 10 Feb 2014 04:16:10 +0000

Running CLI
java -jar jenkins-cli.jar [-s JENKINS_URL] command [options…] [arguments…]

Getting help
java -jar jenkins-cli.jar -s yourserver.com help [command]

Running commands against a secure Jenkins (basic auth or ssh keys)

$ java -jar jenkins-cli.jar -s http://myjenkins help –username me –password mypassword
$ java -jar jenkins-cli.jar -s http://myjenkins help -i ~/.ssh/id_rsa

Passing parameters when triggering a job build
To pass those same parameters via the CLI? You use the -p key=value flag for each parameter you want to pass.

So our finished product might look like:

$ java -jar jenkins-cli.jar -s http://myjenkins build ‘Deploy XYZ App’ -i ~/.ssh/id_rsa -s -v -p target_env=api.cloudfoundry.com -p branch=master

How to get all commands for Jenkins CLI-
Run > http://yourserver.com/cli

java -jar jenkins-cli.jar -s http://fmsscm.corp.intuit.net/qbo-qa/ help

Available Commands

build: Builds a job, and optionally waits until its completion.
cancel-quiet-down: Cancel the effect of the “quiet-down” command.
clear-queue: Clears the build queue
connect-node: Reconnect to a node
console: Retrieves console output of a build
copy-job: Copies a job.
create-job: Creates a new job by reading stdin as a configuration XML file.
create-node: Creates a new node by reading stdin as a XML configuration.
delete-builds: Deletes build record(s).
delete-job: Deletes a job
delete-node: Deletes a node
disable-job: Disables a job
disconnect-node: Disconnects from a node
enable-job: Enables a job
get-job: Dumps the job definition XML to stdout
get-node: Dumps the node definition XML to stdout
groovy: Executes the specified Groovy script.
groovysh: Runs an interactive groovy shell.
help: Lists all the available commands.
install-plugin: Installs a plugin either from a file, an URL, or from update center.
install-tool: Performs automatic tool installation, and print its location to stdout. Can be only called from inside a build.
keep-build: Mark the build to keep the build forever.
list-changes: Dumps the changelog for the specified build(s).
list-jobs: Lists all jobs in a specific view or item group.
list-plugins: Outputs a list of installed plugins.
login: Saves the current credential to allow future commands to run without explicit credential information.
logout: Deletes the credential stored with the login command.
mail: Reads stdin and sends that out as an e-mail.
offline-node: Stop using a node for performing builds temporarily, until the next “online-node” command.
online-node: Resume using a node for performing builds, to cancel out the earlier “offline-node” command.
quiet-down: Quiet down Jenkins, in preparation for a restart. Don’t start any builds.
reload-configuration: Discard all the loaded data in memory and reload everything from file system. Useful when you modified config files directly on disk.
restart: Restart Jenkins
safe-restart: Safely restart Jenkins
safe-shutdown: Puts Jenkins into the quiet mode, wait for existing builds to be completed, and then shut down Jenkins.
session-id: Outputs the session ID, which changes every time Jenkins restarts
set-build-description: Sets the description of a build.
set-build-display-name: Sets the displayName of a build
set-build-parameter: Update/set the build parameter of the current build in progress
set-build-result: Sets the result of the current build. Works only if invoked from within a build.
set-external-build-result: Set external monitor job result.
set-next-build-number: Set build number to be used for next build.
shutdown: Immediately shuts down Jenkins server
update-job: Updates the job definition XML from stdin. The opposite of the get-job command
update-node: Updates the node definition XML from stdin. The opposite of the get-node command
version: Outputs the current version.
wait-node-offline: Wait for a node to become offline
wait-node-online: Wait for a node to become online
who-am-i: Reports your credential and permissions

The post Understand Jenkins CLI | Jenkins CLI Reference appeared first on scmGalaxy.

Maven CLI Options Reference – Command Line | Maven Command Line Cheatsheet

scmgalaxy K — Thu, 12 Sep 2013 10:06:42 +0000

Maven CLI Options Reference

Options	Description
`-am,--also-make`	If project list is specified, also build projects required by the list
`-amd,--also-make-dependents`	If project list is specified, also build projects that depend on projects on the list
–B,–batch-mode	Run in non-interactive (batch) mode
`-C,--strict-checksums`	Fail the build if checksums don’t match
`-c,--lax-checksums`	Warn if checksums don’t match
`-cpu,--check-plugin-updates`	Ineffective, only kept for backward compatibility
`-D,--define`	Define a system property
`-e,--errors`	Produce execution error messages
`-emp,--encrypt-master-password`	Encrypt master security password
`-ep,--encrypt-password`	Encrypt server password
`-f,--file`	Force the use of an alternate POM file (or directory with pom.xml).
`-fae,--fail-at-end`	Only fail the build afterwards; allow all non-impacted builds to continue
`-ff,--fail-fast`	Stop at first failure in reactorized builds
`-fn,--fail-never`	NEVER fail the build, regardless of project result
`-gs,--global-settings`	Alternate path for the global settings file
`-h,--help`	Display help information
`-l,--log-file`	Log file to where all build output will go.
`-llr,--legacy-local-repository`	Use Maven 2 Legacy Local Repository behaviour, ie no use of _maven.repositories. Can also be activated by using -Dmaven.legacyLocalRepo=true
`-N,--non-recursive`	Do not recurse into sub-projects
`-npr,--no-plugin-registry`	Ineffective, only kept for backward compatibility
`-npu,--no-plugin-updates`	Ineffective, only kept for backward compatibility
`-nsu,--no-snapshot-updates`	Suppress SNAPSHOT updates
`-o,--offline`	Work offline
`-P,--activate-profiles`	Comma-delimited list of profiles to activate
`-pl,--projects`	Comma-delimited list of specified reactor projects to build instead of all projects. A project can be specified by [groupId]:artifactId or by its relative path.
`-q,--quiet`	Quiet output – only show errors
`-rf,--resume-from`	Resume reactor from specified project
`-s,--settings`	Alternate path for the user settings file
`-T,--threads`	Thread count, for instance 2.0C where C is core multiplied
`-t,--toolchains`	Alternate path for the user toolchains file
`-U,--update-snapshots`	Forces a check for updated releases and snapshots on remote repositories
`-up,--update-plugins`	Ineffective, only kept for backward compatibility
`-V,--show-version`	Display version information WITHOUT stopping build
`-v,--version`	Display version information
`-X,--debug`	Produce execution debug output

The post Maven CLI Options Reference – Command Line | Maven Command Line Cheatsheet appeared first on scmGalaxy.