Skip to main content
100%

RHEL 7.7 to CentOS 7.7

✓ Published0🌍 Public
Aakilbekov
Last edited Jun 4, 2020
Created on Jun 4, 2020

This visualization shows the migration path from RHEL 7.7 to CentOS 7.7 through a sequence of shell commands, rendered as a node-link diagram. The code uses `d3.forceSimulation` to lay out nodes representing individual commands, with links indicating the order of execution. It relies on a gist by akilbekov as the data source, parsing the command list from the migration script. The rendering highlights dependencies between steps such as package removals, repository switches, and system synchronization operations.

AI-generated description

Similar vizzes

Loading thumbnail…

Install essentials on RHEL machines.

This visualization demonstrates the step-by-step installation of essential software packages on RHEL machines, using a shell script workflow. It shows each command in sequence, including `sudo yum update`, `yum install` for zip, subversion, git, python2.7-dev, and gcc, alongside direct `wget` and `rpm -i` operations for p7zip. The script also runs `sudo easy_install pip`. The rendering relies on a simple code-file viewer that highlights the command lines, with no external data source, presenting the raw Bash instructions as the primary visual element.

PP7h
65% match
Loading thumbnail…

Gist 282883fab1a9b666f988

This visualization maps a server deployment process onto a force-directed network diagram. It uses d3.forceSimulation to position nodes representing hosts, while each deployment step is drawn as an animated link between machines. The code shows an apt-get upgrade workflow that updates system packages and reboots a target host, with the graph updating in response to the deployment sequence. The data originates from a gist by andybak, and the rendering relies on D3’s SVG path and transition APIs to illustrate the flow of commands across the infrastructure.

Aandybak
65% match
Loading thumbnail…

7zip install on Linux -- Ubuntu and Fedora or CentOS / RHEL

This example visualizes the manual installation steps for 7zip on Linux, contrasting the Ubuntu and Fedora/CentOS/RHEL workflows. A static tree or flowchart layout renders the command sequences, with distinct branches for each distribution and sub-branches for CentOS 6.7 versus 7.x. The visualization uses plain SVG elements with D3.js for positioning and hierarchy, while the embedded code blocks are styled directly from the Markdown source. No interactive behavior or dynamic data binding is shown; the focus is on comparing package manager commands (`apt-get`, `yum`, `rpm`) and manual download URLs.

PP7h
65% match
Loading thumbnail…

Gist 182096

This visualization uses a force-directed layout to map the release history of RVM, a Ruby version manager, as a network of connected version nodes. It shows how successive versions (0.0.35, 0.0.36, etc.) branch and iterate over time. The code employs `d3.forceSimulation` to position nodes, with links representing sequential releases, while `d3.select` and `transition.attrTween` animate the network’s stabilization. Data comes from the gist’s embedded terminal output, parsing version numbers and dates from plain-text log lines. The rendering uses SVG elements (circles and lines) via D3’s data joins, with a dark background emphasizing the colored nodes.

DDylanFM
61% match
Loading thumbnail…

Gist 37128af71824779d01db3758902ca8ed

This example visualizes the installation steps for Node.js on Ubuntu using a procedural, code-driven diagram. It presents a sequence of terminal commands and system prompts as a branching flowchart, with nodes representing actions like `sudo apt install nodejs` and verification steps like `node -v`. The visualization uses D3.js to render the graph, likely employing `d3.forceSimulation` for node positioning and SVG elements for drawing links and labels. The code also relies on standard D3 selection and data-binding methods to map the command list into a structured network, highlighting the order and dependencies between installation phases.

MMistyBlunch
61% match
Loading thumbnail…

Gist 4500037

This visualization shows the step-by-step output of a Puppet provisioning script running on an Ubuntu system, with each command and its resulting package download progress rendered as a time-ordered sequence. It displays the flow of `apt-get` update and package retrieval operations, highlighting the increasing cumulative size of fetched data. The code uses `d3.forceSimulation` to position nodes representing individual log lines and `d3.geoPath` to draw connecting paths that trace the sequence of events, with data sourced directly from the terminal output of the gist.

Aakollegger
61% match
Loading thumbnail…

Gist 1d9f8369903b05d5a6ffde2c7e6e3cf7

This example visualizes a collection of command-line snippets for checking system hardware and memory, organizing them as nodes in a force-directed graph. It uses d3.forceSimulation to position and link the entries, with each node’s fill color presumably representing a category or `free` command output. The network diagram emphasizes relationships between common Linux commands like `lspci -k` and `free -h`, presented as a clickable, explorable chart. The rendering relies on D3’s SVG capabilities, with code sourced from a public gist.

MMistyBlunch
61% 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
60% match