Skip to main content
100%

Shell script to wait on a upstream jenkins job - a "block" node in an execution graph

✓ Published0🌍 Public
Aandyreagan
Last edited May 22, 2020
Created on May 22, 2020

A shell script uses the Jenkins REST API to wait for upstream jobs to finish, polling each job’s `/api/json?pretty=true` endpoint with Python’s `requests` and `json` libraries. It checks the `color` field for `"anime"` to detect a running build, sleeping 5 seconds between polls. After completion, it asserts that the last completed build equals the last successful build, confirming success. The script supports multiple upstream jobs by splitting a comma-separated `JOB_TO_WAIT_FOR` variable and tracking status in a list, effectively acting as a blocking node in an execution graph.

AI-generated description

Similar vizzes

Loading thumbnail…

Genie Job Heartbeat

This example monitors the runtime status of a Netflix Genie job by emitting an audible beep each time the job is confirmed to be running. It shows a continuous polling loop that checks the job’s state through the Genie REST API, specifically querying the `/api/v3/jobs` endpoint with a size limit of 100 results. The script uses `curl` to fetch the JSON response and `jq` to filter the job list for the target job ID and its current status, grepping for the string “RUNNING” to trigger the terminal bell via `tput bel`. The loop repeats at a user-defined interval until the job leaves the running state.

Aadkatrit
52% match
Loading thumbnail…

Gist 9979190ea462c76d13e80def7b5aa3d8

This example demonstrates a Node.js script that checks whether the current Git branch is "master" before allowing a publish operation. It shows how to enforce a branch-based gate using the `execa` library to run `git symbolic-ref --short HEAD` and compare the output. The visualization highlights the workflow of validating Git state programmatically, with the script exiting with an error if the branch condition is not met. The code uses `execa.stdout` for asynchronous command execution, mirroring patterns from the `np` package. The rendering approach is text-based, relying on console output for success or failure.

HHypercubed
51% match
Loading thumbnail…

Gist 7ea7490cb95fe21dfad10572a1c8244f

This example visualizes the process of checking and updating the UPX executable packer to its latest release version. It shows a shell-script-driven workflow that queries the GitHub API for the newest release tag, compares it to the locally installed version, and either reports the tool is up to date or proceeds to download, compile, and install the source tarball. The code relies on standard command-line utilities (`curl`, `jq`, `tar`, `make`) and directly parses version strings, without any graphical or interactive rendering libraries. The rendering approach is purely textual terminal output, with no data visualization beyond status messages.

HHerst
47% match
Loading thumbnail…

Gist 83e1b6fcb5b1da33f595c08405f89f2a

This example visualizes a system administration workflow that automatically masks or unmasksthe Linux sleep and suspend targets based on active SSH sessions. It shows a shell script that counts established SSH connections on port 22 using `ss` and `awk`, then conditionally runs `systemctl mask` or `systemctl unmask` on `sleep.target` and `suspend.target`. The visualization highlights the script’s branching logic driven by `PAM_TYPE` (open or close session) and the connection count. No external charting library is used; the code relies on standard shell utilities (`ss`, `awk`, `logger`, `sudo`) to manage systemd power management.

HHerst
46% match
Loading thumbnail…

Gist 39225

This visualization presents a server-stack installation script, not a typical data-driven graphic. It maps the procedural flow of an unattended Bash deployment of Ruby Enterprise and the Passenger Apache module, tracing each command and conditional branch as a node in a directed graph. The code uses a custom layout to arrange the script’s logic, with nodes representing commands like `sudo apt-get install` and `gem install`, while edges show the sequence and decision points (e.g., `if [ -e $REEF ]`). The rendering approach highlights the script’s structure, with color coding for installation steps versus error-handling exits, and the data source is the literal Bash code itself, parsed to extract control flow.

DDylanFM
46% match
Loading thumbnail…

Node.js tartup script for AWS EC2 Linux box

This shell script provides a startup and service management routine for a Node.js server on an AWS EC2 Linux instance. It defines start, stop, and restart functions that launch the Node process as the ec2-user, redirecting output to a log file, and manage a lock file to track service status. The script uses standard init.d functions like `daemon`, `killproc`, and `status` from `/etc/rc.d/init.d/functions`, and it raises the file descriptor limit with `ulimit`. It reads optional configuration from `/etc/sysconfig/nodejs` and handles command-line actions including start, stop, restart, reload, condrestart, and status.

Aalessioalex
46% match
Loading thumbnail…

Gist 53be55d85e6606f7de68977cfbf66429

This example shows a GitHub Actions workflow for a release pipeline, visualized as a directed graph of jobs and their dependencies. The diagram displays lint, test, release, and post-release stages, with parallel branches and explicit needs relationships between jobs. It uses the YAML configuration from the repository's release workflow, rendered with a custom visualization library that maps job names, runner labels, and step sequences into nodes and edges. The graph highlights duplicated job definitions and the branching structure of the release process.

Aamazingandyyy
46% match
Loading thumbnail…

Gist 44be7198b7913c5e683122ab224baa9e

This example demonstrates a shell-based spinner that provides visual feedback during a long-running command-line task. Instead of a graphical chart, it renders a rotating line animation directly in the terminal by updating a single carriage-returned character (`\r`) on the standard error stream. The script iterates through the characters of the string `/|-\` using a modulo index, printing one frame per line of piped input. It relies on standard shell constructs like `printf`, a `while` loop with `read`, and an environment variable for state, with no external JavaScript libraries or data sources involved. The spinner stops and clears the line after the input stream ends.

HHerst
46% match