unix on A Scripter's Notes

Version controlling Jenkins config

Kaushal.Modi@fakeEmailToMakeValidatorHappy.com (Kaushal Modi) — Wed, 20 Jul 2022 00:18:00 -0400

Jenkins is an amazing free and open source continuous integration and deployment software. But its primary means of configuration is a web UI, and recently that cost me a lot of debug time. That set me down the path of figuring out a way to version control the Jenkins config (the $JENKINS_HOME directory).

Table of Contents

What bit me
.gitignore for Jenkins config
Jenkins Plugin Manager
Full solution

Jenkins is a wonderful piece of software and I use it with my Bitbucket git repos for CI/CD.

Jenkins uses a web UI for its configuration. I dislike that because it’s difficult to document the configuration process without screenshots, and if I need to create a new server, it’s a manual process of clicking through tabs and filling in the text boxes. I didn’t mind this enough to do anything about it .. that is until I finally got bit by it.

What bit me #

Without going into too much detail, that issue was multi-fold:

I had unknowingly messed up the Project-based Matrix Authorization Strategy such that other users in my team were not able to view the Jenkins jobs.
I had also updated the Jenkins server that introduced a bug (JENKINS-68748) where the Test LDAP Settings failed with an error, but the LDAP authentication actually worked!
I had also updated all the plugins after updating Jenkins. So if I rolled back the Jenkins versions, most of the plugins would fail because of incompatibility with the older Jenkins version. I had updated Jenkins after months!

That’s when I wished that my whole Jenkins was version-controlled. That would have allowed me to roll back to the last working “Jenkins image” with the Jenkin version, plugins' versions and my Jenkins config all in sync.

I had delayed doing this because my $JENKINS_HOME was more than 1GB in size and I didn’t have time or motivation to figure out what stuff I should commit and what I should ignore .. But no more — The time had finally come.

`.gitignore` for Jenkins config #

So I did what any good engineer would do .. start looking for a solution online. I found this StackOverflow answer for Is there a way to keep Hudson / Jenkins configuration files in source control?.

That answer shares a .gitignore that ignores files not necessary for configuring a Jenkins server — Example: job builds, workspace, log files, etc. But it didn’t work out of the box because the plugin version info wasn’t getting committed correctly. I had committed everything to git after using the suggested .gitignore and pushed to my git remote. But if I cloned that repo to a different area and attempted to start the Jenkins server from there, it crashed with this message:

2022-07-15 13:07:06.082+0000 [id=31] SEVERE jenkins.InitReactorRunner$1#onTaskFailed: Failed Loading global config
com.thoughtworks.xstream.mapper.CannotResolveClassException: hudson.security.ProjectMatrixAuthorizationStrategy
 at com.thoughtworks.xstream.mapper.DefaultMapper.realClass(DefaultMapper.java:81)
 at com.thoughtworks.xstream.mapper.MapperWrapper.realClass(MapperWrapper.java:125)
 at com.thoughtworks.xstream.mapper.DynamicProxyMapper.realClass(DynamicProxyMapper.java:55)
 at com.thoughtworks.xstream.mapper.MapperWrapper.realClass(MapperWrapper.java:125)
 at com.thoughtworks.xstream.mapper.PackageAliasingMapper.realClass(PackageAliasingMapper.java:88)
 at com.thoughtworks.xstream.mapper.MapperWrapper.realClass(MapperWrapper.java:125)
 at com.thoughtworks.xstream.mapper.ClassAliasingMapper.realClass(ClassAliasingMapper.java:79)
 at com.thoughtworks.xstream.mapper.MapperWrapper.realClass(MapperWrapper.java:125)
 at com.thoughtworks.xstream.mapper.ArrayMapper.realClass(ArrayMapper.java:74)
 at com.thoughtworks.xstream.mapper.MapperWrapper.realClass(MapperWrapper.java:125)
 at com.thoughtworks.xstream.mapper.SecurityMapper.realClass(SecurityMapper.java:71)
 at com.thoughtworks.xstream.mapper.MapperWrapper.realClass(MapperWrapper.java:125)
 at hudson.util.XStream2$CompatibilityMapper.realClass(XStream2.java:411)
 at hudson.util.xstream.MapperDelegate.realClass(MapperDelegate.java:46)
 at com.thoughtworks.xstream.mapper.MapperWrapper.realClass(MapperWrapper.java:125)
 at com.thoughtworks.xstream.mapper.CachingMapper.realClass(CachingMapper.java:47)
 at hudson.util.RobustReflectionConverter.determineType(RobustReflectionConverter.java:521)
 at hudson.util.RobustReflectionConverter.doUnmarshal(RobustReflectionConverter.java:346)
Caused: jenkins.util.xstream.CriticalXStreamException:
---- Debugging information ----
cause-exception : com.thoughtworks.xstream.mapper.CannotResolveClassException
cause-message : hudson.security.ProjectMatrixAuthorizationStrategy
class : hudson.model.Hudson
required-type : hudson.model.Hudson
converter-type : hudson.util.RobustReflectionConverter
path : /hudson/authorizationStrategy
line number : 12
version : not available
-------------------------------

Code Snippet 1: Snippet of Jenkins crash when attempting to run the server from the freshly cloned git repo

Jenkins Plugin Manager #

So I reached out for help on the Jenkins Community. One of the key contributors to Jenkins, Mark Waite, was tremendously helpful. He suggested using his jenkins-plugin-manager tool. After trying it out for a bit, I realized that this tool had everything I needed for version controlling the plugin versions:

Ability to save a list of installed Jenkins plugins and their versions to a file.
Ability to batch install all the plugins of the versions listed in a file.

This was like doing Python’s plugin management using requirements.txt, except that this was for Jenkins.

Full solution #

With a combination of the .gitignore that I started with from that SO answer, managing plugins using jenkins-plugin-manager, tweaking the .gitignore to my liking, and adding helper Bash scripts for downloading and running Jenkins server binaries, and doing the plugin management, I finally got what I needed:

https://github.com/kaushalmodi/jenkins-minimal

The README on the repo has all the instructions.

Disarming the 'tar' bomb in 10 seconds

Kaushal.Modi@fakeEmailToMakeValidatorHappy.com (Kaushal Modi) — Mon, 13 Jun 2022 01:14:00 -0400

Use tar -caf <file> <dir> to create an archive, tar -xf <file> to extract one, and more.

Table of Contents

Mnemonics
Creating an archive
Extracting an archive
Listing contents of an archive
Summary

I had come across this post by user Garrit on Mastodon, and that inspired this post.

In reply to:

https://garrit.xyz/posts/2022-06-02-tar-commands

A post on the Unix command tar cannot leave out the obligatory xkcd tar comic 😄, so here it is:

xkcd.com

Mnemonics #

These few mnemonics help me remember the basic and my most frequently used tar options:

c to (c)reate
a to (a)uto compress the archive based on the file name
x to e(x)tract
f for the archive (f)ile name we are dealing with (whether creating, listing or extracting an archive)

.. and a few not so frequent options (for me):

t to lis(t) contents of an archive
v for (v)erbose output

Creating an archive #

tar -caf <file> <dir>

A keen user might have noticed that I am using tar -caf .. instead of tar caf .. i.e. I am using a hyphen before the tar options. Both approaches work and they look similar, but the approach with the hyphen is the newer Short Option style while the other is the Old Option style.

I prefer the short option style because .. well.. the other style is old.. and also because the short option style is stricter e.g. the -f switch has to be followed by the file name.

Whether you are creating a regular .tar archive, or a compressed archive like .tar.gz, always use the auto-compresion switch -a. That relieves you from deciding if you need that switch, or which compression algorithm switch should be used 😄.

The -a switch makes the decision for you based on the file extension. For example, tar -caf foo.tar foo/ will create a regular archive, while tar -caf foo.tar.gz foo/ will create a compressed archive using gzip. You can read more about it in Creating and Reading Compressed Archives.

Extracting an archive #

tar -xf <file>

At times, it might be useful to add the verbosity switch -v to this command and do tar -xvf <file>.

Just to reiterate, the -f switch must be followed by the archive file name.

Listing contents of an archive #

tar -tf <file>

Once you are done creating an archive, you might feel the need to check if the archive contains everything you expect. Or you might want to check what’s inside the archive before you extract it.

This command is often paired with grep or rg (ripgrep) like so: tar -tf foo.tar.xz | rg 'some_file_name_in_archive'.

Summary #

If you simply glossed over the whole article, or didn’t read through the all linked manual pages I know you didn’t 😉 , just remember this —

tar -caf to create and tar -xf to extract

grep -Po

Kaushal.Modi@fakeEmailToMakeValidatorHappy.com (Kaushal Modi) — Wed, 16 Feb 2022 21:34:00 -0500

Using grep to do substring extraction in shell scripts.

Table of Contents

Problem statement
Solution using grep -Po
Arriving to this solution
Summary

I like regular expressions I recommend using https://regex101.com/ to practice regular expressions of different flavors (PCRE2, PCRE, Python, etc.) whether or not you are new to using regex. as they allow me to be concise and specific about what I need to search.

And I have liked using regular expressions for many years, ever since I learned Perl about fifteen years back. I am writing this post as I am remembering the delight I felt when I realized that I can use the familiar Perl regular expressions to do string parsing in shell scripts. I am not exactly sure, but I probably learned about this grep -Po trick from stackexchange (camh, 2011).

Problem statement #

I could be parsing a log file with a line like web report: https://foo.bar/detail.html and I need to extract the https://foo.bar part to a shell script variable.

Solution using `grep -Po` #

This solution requires a GNU grep version supporting -P, that’s compiled with libpcre. GNU grep gained the PCRE (-P) feature back in 2000. Also I have never come across a system or used one that did not have such a grep version installed.

I’ll throw the solution out here and then dig into the details.

echo "def\nabc" | grep -Po 'a\K.(?=c)' # => b

Code Snippet 1: Extracting "b" from "abc" using grep -Po

The grep switches used here are:

-P: Use (P)erl regular expressions. This allows us to use the look around regex syntax like (?=..) and special characters like \K (“perlre - Perl regular expressions,” n.d.).
-o: Print only the matched portion to the (o)utput

Arriving to this solution #

Now I’ll start with a basic example and build up to the above solution.

Problem: Let’s say I have this text with two lines “def” and “abc” and I want to output whatever character is between “a” and “c”.

Below, the regular expression for matching any character between “a” and “c” ( 'a.c' ) is correct, but that will output the whole input because the grep of that regex succeeded.
```
echo "def\nabc" | grep 'a.c' # => def\nabc
```
Now we add the grep -o switch so that it outputs only the matched portion. As the regex is 'a.c', the -o switch will output every part of the input that matched that. So the output is “abc”. It’s still not what we wanted.
```
echo "def\nabc" | grep -o 'a.c' # => abc
```
Now we bring in the powerful Perl regex feature positive lookahead. Positive lookahead is used when you want to match something only if it’s followed by something else. It’s syntax looks like q(?=u) where that expression matches if a q is followed by a u, without making the u part of the match – reference. But this is still not exactly what we want because “a” is still considered as part of the match. Now the output is “ab”.
```
echo "abc" | grep -Po 'a.(?=c)' # => ab
```
We only need a special character that marks a point in the regex that tells “don’t consider anything before this as part of the match”. The \K special construct described in the Perl regular expressions doc as:

There is a special form of this construct, called \K (available since Perl 5.10.0), which causes the regex engine to “keep” everything it had matched prior to the \K and not include it in matched string. This effectively provides non-experimental variable-length lookbehind of any length.

And, thus we have the final solution:
```
echo "abc" | grep -Po 'a\K.(?=c)' # => b
```

Summary #

Taking the example from the problem statement, this will work:

string="web report: https://foo.bar/detail.html"
substring=$(grep -Po 'web report:\s*\K.*?(?=/detail\.html)' <<< "${string}")
echo "${substring}"

https://foo.bar

References #

camh. (2011). Can grep output only specified groupings that match? [Website]. In Unix stackexchange. https://unix.stackexchange.com/a/13472/57923

perlre - Perl regular expressions. (n.d.). [Website]. In Perldoc 5.34.0. Retrieved February 16, 2022, from https://perldoc.perl.org/perlre

Git diff Minified JS and CSS

Kaushal.Modi@fakeEmailToMakeValidatorHappy.com (Kaushal Modi) — Mon, 19 Mar 2018 18:13:00 -0400

Make the git diff output be more useful when diffing minified .js and .css files.

Table of Contents

1 Install js-beautify using npm
2 Configure git to use that tool
3 Add/update .gitattributes file to the project repo
Beautiful Result

While working on a little PR for the Hugo doc site theme, I learned that if I needed to make changes to JS/CSS, I had to commit my changes in both unminified and minified versions.

I have a habit to always look at the diffs at the time of staging and committing. So it felt very unnatural to commit a minified JS where the diff would show just one changed line with thousands of characters of minified+uglified JS.

So I started looking for solutions, and found this post by Christian Weiske where he suggests using js-beautify to beautify minified JS diffs.

And that tool works beautifully!

I later found out that the same tool can also be used to beautify minified CSS.
.. and I installed that tool using npm as the pip3 approach failed with “Collecting js-beautify.. Could not find a version that satisfies the requirement js-beautify (from versions: ) No matching distribution found for js-beautify”.

So here’s how you can do useful git diff for minified JS and CSS.

1 Install `js-beautify` using `npm` #

I see myself using js-beautify in many other projects too. So I installed it globally.

npm install --global js-beautify

2 Configure `git` to use that tool #

Add below to your ~/.gitconfig:

Use js-beautify to first beautify the minified JS for the minjs diff configuration, and then do a diff of those beautified files.
Enable caching of those beautified files to speed up the diff, so that re-beautification of unmodified minified files can be skipped.
Similarly for minified CSS, use js-beautify --css to first beautify the minified CSS for the mincss diff configuration.

[diff "minjs"]
 textconv = js-beautify
 cachetextconv = true
[diff "mincss"]
 textconv = js-beautify --css
 cachetextconv = true

3 Add/update `.gitattributes` file to the project repo #

Now, in your project repo’s .gitattributes file, you need to associate files with the diff configurations set above.

Below will use the minjs configuration for *.min.js and *.bundle.js files, and mincss configuration for *.min.css and main.css.

*.min.js diff=minjs
*.bundle.js diff=minjs
*.min.css diff=mincss
main.css diff=mincss

Beautiful Result #

Figure 1: git diff of minified JS as seen in Magit

Isn’t that better than how GitHub shows the exact same commit diff? 😎

Figure 2: Same commit diff shown on GitHub

Installing go toolchain

Kaushal.Modi@fakeEmailToMakeValidatorHappy.com (Kaushal Modi) — Fri, 24 Feb 2017 01:33:47 -0500

“Installing” go is simply extracting its release archive, putting it somewhere in you $HOME and pointing GOROOT and PATH env vars to it.

Table of Contents

Installing go
Updating go

There are two reasons why I suggest installing go to anyone, whether they are Go developers, or not (like me).

You can then build amazing utilities like peco, hugo and noti.
It’s easy!

Installing `go` #

Below instructions are for installing go on a 64-bit GNU/Linux machine, and using tcsh shell. But similar steps should work for any other OS and shell.

Download the tar.gz for the latest linux-amd64 binaries from https://golang.org/dl/.
Extract it to some place in your $HOME. I extract it to ${HOME}/go/¹.
Create a directory where you would want to install the go packages.
```
mkdir -p ~/go.apps
```

Set the following environment variables², and also save them to your shell config:

setenv GOROOT ${HOME}/go # go root
setenv GOPATH ${HOME}/go.apps # for go applications

Add the ${GOROOT}/bin and ${GOPATH}/bin directories to your $PATH.

Now you can install any go application!

For instance, noti is a nice little utility that triggers an alert (desktop popup, Pushbullet notification, etc.) when a process finishes. From its installation notes, you just run the below to install it:

go get -u github.com/variadico/noti/cmd/noti

Apart from the go applications I suggested here, go out and explore more – go get them 😁

Updating `go` #

Delete the existing $GOROOT directory (not GOPATH!)
```
rm -rf ~/go # as that is my GOROOT
```
Download the tar.gz for the latest linux-amd64 binaries.
Extract it to the same $GOROOT (~/go in my case).

I prefer to not add the version number to my go installation folder. That way, when I want to update it, I simply rm -rf it and put in the new version.. and I don’t need to update GOROOT or PATH. ↩︎
You can refer to these official go references [ 1 ], [ 2 ] for further information on these variables. ↩︎

Count Down Timer in Shell

Kaushal.Modi@fakeEmailToMakeValidatorHappy.com (Kaushal Modi) — Mon, 09 Jan 2017 08:02:25 -0500

I was working on a tcsh script that did some cool stuff. But if a user ran that script not knowing the true impact of the script, it could make some bad irreversible changes.

While I could simply echo a warning statement and put a sleep 10, I wanted the wait time to be shown live.

Table of Contents

Explanation
Result
Bash implementation

So here’s what worked pretty nicely — The warning message is shown to the user, and the actual wait time countdown is also displayed.

#!/usr/bin/env tcsh
set wait_time = 10 # seconds

echo "Are you sure you meant to run this script?"
echo "This script does something drastic that you would severely regret if you happened to run this script by mistake!"
echo ""
set temp_cnt = ${wait_time}
# https://www.cyberciti.biz/faq/csh-shell-scripting-loop-example/
while ( ${temp_cnt} >= 1 )
 printf "\rYou have %2d second(s) remaining to hit Ctrl+C to cancel that operation!" ${temp_cnt}
 sleep 1
 @ temp_cnt--
end
echo ""

Explanation #

The while loop runs for $wait_time times; each time waiting for a second (sleep 1) and then decrementing the temporary counter $temp_cnt.
printf is chosen instead of echo -n because I wanted to have the seconds number always hold 2 character places (%2d).
The \r character in printf makes the magic here. It represents carriage return i.e. The cursor will return to the beginning of the line, and then print the following string, overwriting whatever there was on that line earlier.
- printf acts like echo -n i.e. a newline is not inserted automatically at the end of the printed message. In order to add a newline at the end for printf, you need to do so explicitly by adding a \n character.

Result #

Click here to see the animation on asciinema.org.

Bash implementation #

Below is a re-implementation of the above in bash.

#!/usr/bin/env bash
wait_time=10 # seconds

echo "Are you sure you meant to run this script?"
echo "This script does something drastic that you would severely regret if you happened to run this script by mistake!"
echo ""
temp_cnt=${wait_time}
while [[ ${temp_cnt} -gt 0 ]];
do
 printf "\rYou have %2d second(s) remaining to hit Ctrl+C to cancel that operation!" ${temp_cnt}
 sleep 1
 ((temp_cnt--))
done
echo ""

Check If a Command/Executable Exists from Shell Script

Kaushal.Modi@fakeEmailToMakeValidatorHappy.com (Kaushal Modi) — Wed, 23 Nov 2016 17:07:26 -0500

Shell script snippets to check if you have an executable or binary installed in PATH.

Table of Contents

Bash Shell
Tcsh Shell

I often need to check if a particular executable is present in the PATH before I can proceed with what I am doing in a shell script. Also, I need to work with both tcsh and bash scripts. Below presents the solution that has worked for these shell scripts for me.

Bash Shell #

The below solution using hash was with the help of this SO solution.

if ! hash some_exec 2>/dev/null
then
 echo "'some_exec' was not found in PATH"
fi

Here is the tl;dr from the above SO solution:

Where bash is your shell/hashbang, consistently use hash (for commands) or type (to consider built-ins & keywords). When writing a POSIX script, use command -v.

Tcsh Shell #

As it turns out, the tcsh shell does not have the same hash command as the bash shell.

But the below solution using where which I found with the help of this SO solution works fine.

if ( `where some_exec` == "" ) then
 echo "'some_exec' was not found in PATH"
endif

Second Argument to basename

Wed, 23 Nov 2016 13:24:45 -0500

It is quite common knowledge that the basename command is used to get just the file name without its full path.

> basename /home/$USER/file.txt
file.txt

But what wasn’t common knowledge, at least to me, was that basename also accepts a second argument ..

That argument is used to specify the trailing string to be removed from first argument.

From man basename, we get

DESCRIPTION
Print NAME with any leading directory components removed. If
specified, also remove a trailing SUFFIX.
EXAMPLES
basename /usr/bin/sort
Output "sort".
basename include/stdio.h .h
Output "stdio".

In other words, with the second argument set to the file’s extension, basename returns the file name without the full path and without the extension.

> basename /home/$USER/file.txt .txt
file

I came across this feature of basename when I wanted to create this tcsh alias:

# Usage: md2 html file.md # Converts file.md (markdown) to file.html
# md2 pdf file.md # Converts file.md (markdown) to file.pdf
# md2 docx file.md # Converts file.md (markdown) to file.docx (Word)
alias md2 'pandoc \!:3* \!:2 -o `basename \!:2 .md`.\!:1'

tmux Shift + Mouse

Kaushal.Modi@fakeEmailToMakeValidatorHappy.com (Kaushal Modi) — Thu, 28 Aug 2014 16:47:46 -0400

Using mouse to copy/paste in tmux panes.

I had been missing the “select and middle-click” method for copying and pasting stuff in tmux panes.

Thanks to this post, I learned that I can use the Shift key and bypass tmux’s own copy and paste method.

Key/Mouse Binding	Action
`Shift` + Mouse left button double-click	Copies the double-clicked word
`Shift` + Select using mouse	Copies the selection
`Shift` + Mouse middle button click	Pastes the copied text using above method in the `tmux` pane

Using sed

Mon, 17 Mar 2014 09:31:29 -0400

sed stands for stream editor.

This is the most common way of my sed usage:

echo [SOMETHING] | sed 's/old/NEW/g'

Based on that, I have this tcsh alias¹ to get timestamps that I use to append to quick tar backups.

alias gettimestamp 'date | tr " :" "__" | sed '"'"'s/_[0-9]*_EDT.*//g'"'"''

Learn about sed from [here][s1].

Note how single quotes are escaped inside single-quoted alias definitions in tcsh. [s1]: http://www.grymoire.com/Unix/Sed.html ↩︎

Send a command to every pane/window/session in tmux

Kaushal.Modi@fakeEmailToMakeValidatorHappy.com (Kaushal Modi) — Thu, 06 Mar 2014 09:50:21 -0500

Faster way to send the same command to each and every pane in your tmux session.

Table of Contents

Send command to all panes in all sessions
- Usage
- About the ##
Send command to all panes in current session
Older version (circa 2014)

Ever wondered how you would send the clear command to each pane, in each window, in each session in tmux, or how you would do source your shell config file in each after each tweak?

Here are few excerpts from my .tmux.conf that allow doing just that.

Send command to all panes in all sessions #

Thanks to the tip in comments from Bob Fleming, I learned that tmux has a -a switch for the list-panes command.

From man tmux,

list-panes [-as] [-F format] [-t target]
 (alias: lsp)
 If -a is given, target is ignored and all panes on the server
 are listed. If -s is given, target is a session (or the
 current session). If neither is given, target is a window (or
 the current window). For the meaning of the -F flag, see the
 FORMATS section.

With that knowledge, the older version of the E binding now reduces to,

# Send the same command to all panes/windows/sessions
bind E command-prompt -p "Command:" \
 "run \"tmux list-panes -a -F '##{session_name}:##{window_index}.##{pane_index}' \
 | xargs -I PANE tmux send-keys -t PANE '%1' Enter\""

Usage #

Type the following binding in any tmux pane: C-z E¹
Enter a command that you would want to send to all the panes, like source ~/.alias; clear (this is entered in the tmux command prompt).
That will source the ~/.alias in all panes, and then clear the terminals as well.

About the `##` #

The # character needs to be escaped by another # and typed as ##, only when used inside the run-shell command.

.. because otherwise, tmux run-shell command will replace the unescaped #{session_name}, #{window_index} and #{pane_index} with their current values before executing the command.

With the hashes escaped, those variables will be evaluated at run time.

But if you were to type the above command directly in the terminal, without the run-shell command wrapper, you would use only single #:

tmux list-panes -s -F "#{session_name}:#{window_index}.#{pane_index}"

Send command to all panes in current session #

The list-panes command has another useful switch: -s, which takes an optional argument, a session name. If that argument is not supplied, it takes the current session name by default.

Below C-e binding is used to send a command to all panes, in all windows, but only in the current session.

bind C-e command-prompt -p "Command:" \
 "run \"tmux list-panes -s -F '##{session_name}:##{window_index}.##{pane_index}' \
 | xargs -I PANE tmux send-keys -t PANE '%1' Enter\""

Older version (circa 2014) #

# Send the same command to all panes/windows/sessions
bind E command-prompt -p "Command:" \
 "run \"tmux list-sessions -F '##{session_name}' \
 | xargs -I SESS tmux list-windows -t SESS -F 'SESS:##{window_index}' \
 | xargs -I SESS_WIN tmux list-panes -t SESS_WIN -F 'SESS_WIN.##{pane_index}' \
 | xargs -I SESS_WIN_PANE tmux send-keys -t SESS_WIN_PANE '%1' Enter\""

I have set my tmux prefix to C-z. ↩︎

unix on A Scripter's Notes

Version controlling Jenkins config

What bit me #

.gitignore for Jenkins config #

Jenkins Plugin Manager #

Full solution #

Disarming the 'tar' bomb in 10 seconds

Mnemonics #

Creating an archive #

Extracting an archive #

Listing contents of an archive #

Summary #

grep -Po

Problem statement #

Solution using grep -Po #

Arriving to this solution #

Summary #

References #

Git diff Minified JS and CSS

1 Install js-beautify using npm #

2 Configure git to use that tool #

3 Add/update .gitattributes file to the project repo #

Beautiful Result #

Installing go toolchain

Installing go #

Updating go #

Count Down Timer in Shell

Explanation #

Result #

Bash implementation #

Check If a Command/Executable Exists from Shell Script

Bash Shell #

Tcsh Shell #

Second Argument to basename

tmux Shift + Mouse

Using sed

Send a command to every pane/window/session in tmux

Send command to all panes in all sessions #

Usage #

About the ## #

Send command to all panes in current session #

Older version (circa 2014) #

`.gitignore` for Jenkins config #

Solution using `grep -Po` #

1 Install `js-beautify` using `npm` #

2 Configure `git` to use that tool #

3 Add/update `.gitattributes` file to the project repo #

Installing `go` #

Updating `go` #

About the `##` #