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:

1. 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.
2. 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!
3. 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
-------------------------------

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:

The README on the repo has all the instructions.

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

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

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 #

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.

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 #

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

Listing contents of an archive #

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 —

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 #

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

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

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 #

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.

• 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:

1. Use js-beautify to first beautify the minified JS for the minjs diff configuration, and then do a diff of those beautified files.
2. Enable caching of those beautified files to speed up the diff, so that re-beautification of unmodified minified files can be skipped.
3. 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 #

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

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

1. You can then build amazing utilities like peco, hugo and noti.
2. 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.

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

   mkdir -p ~/go.apps
   

4. 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
   

5. 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 #

1. Delete the existing $GOROOT directory (not GOPATH!)

   rm -rf ~/go   # as that is my GOROOT
   

2. Download the tar.gz for the latest linux-amd64 binaries.
3. Extract it to the same $GOROOT (~/go in my case).

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.

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 ""

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

> 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'

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.

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].

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 ## #

.. 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\""