Docker commands vs Docker life cycle - Basic level

Earlier I noticed that there's one problem with Docker support documentation. Unfortunately, while it is possible to find out the very basic scenarios in its Get Started section, you need to dig through the Internet for hours to find information about use cases. Use cases is an answer to the question "What are we trying to do here, anyway?".

So, I started to collect this information for myself and pair it with command sets. Below you can find a use case for setting up a docker image and performing some basic commands on it. I shall extend this collection later, if I'm lucky.

Bash - Bulk file update with find and sed

Doing bulk file update (mind escapes when using complicated patterns):

#!/bin/bash

if [ -z $1 ] || [ -z $2 ]  || [ -z $3 ] || [ -z $4 ]; then
        printf "\nPlease enter:\n
        1. file command-compatible filename pattern
        2. backup suffix for affected files
        3. pattern to replace
        4. replacement\n\n
        For instance, $0 *.txt .xml-backup blue red\n
        This should replace blue with red in all txt files\n\n"
        exit
fi


filename_pattern=$1
backup_suffix=$2
pattern_to_replace=$3
replace_with=$4

find . -type f -name ${filename_pattern} -exec sed -i${backup_suffix} "s|${pattern_to_replace}|$replace_with|g" {} \+

Bash - Cut a fragment of a log by some criteria (like timestamp)

Here is how to cut out a piece of a log between two unique strings (like timestamps):

#!/bin/bash

printf "\nResults are returned *inclusive*\n\n"

if [ -z $1 ] || [ -z $2 ] || [ -z $3 ]; then
        printf "\nPlease enter SUBSTRSTART SUBSTREND and LOGPATH\nFor instance, $0 11:59:17,206 12:02:14,606 test.log\n\n"
        exit
fi

substrstart=$1
substrend=$2
logpath=$3

sed -n "/${substrstart}/,/${substrend}/p" ${logpath} | tee log_excerpt-$(date +%F_%H-%M-%S) | cat

Bash - Getting network data for the port (localhost only)

Getting network data:

#!/bin/bash

printf "\nCurrently for localhost only\n\n"

if [ -z $1 ]; then
    printf "Please enter port and [host]\n\n"
    exit
fi

port=$1
host=localhost

printf '========= lsof -i ============\n\n'

lsof -i :${port}

printf '========= netstat -lnt | grep $port ============\n\n'

netstat -lnt | grep ${port}

printf '========= nc -z $host $port  ============\n\n'

nc -z ${host} ${port}

Bash - kill everything with a matching name

Just a small script for killing matching processes by name:

#!/bin/bash

if [ -z $1 ]
then
    printf "keyword is empty\n\n"
    exit
fi

let k=0
let min=1

# mind the double brakets in do part
for i in $(ps -e | grep "$1"); do ((k++)); done

if [ "${k}" -lt "${min}" ]
then
    printf "no such process to kill\n\n"
    exit
fi


for i in $(ps -e | grep $1 | cut -s -f1 -d\t); do kill -9 ${i}; done

Password generator with bash

Looks like the best way to handle your passwords strongly depends on which password breaking approach is the most effective at the moment, and apparently those ways are changing as quickly as technology develops. Which is why it's unlikely that there will ever be a perfect way to avoid all the risks, but we can design an optimal one.

It occurred to me that first we need to select between two strategies: storing generated password or memorizing them with mnemonics. I don't think it would be a good idea to store memorizable data cause it's too easy to break the pattern, or to try to remember a generated one. As I already can do mnemonics, so I decided to write my own password generator (I like having my own collection of tools).

Solution is based on LINK. Stuff in use: cat, tr, fold, head, /dev/urandom, echo, printf, for each and parameters testing

Configuration - setting up Docker for Ubuntu 19.04

A friend of mine installed fresh Ubuntu 19.04 for which there is no stable docker yet. So we had to do it a slightly more complicated way.  

NOTE: this configuration does not help with running docker over VPN
NOTE: Some of the commands below may require sudo
NOTE: It is assumed that you configure docker for user without sudo, cause using it with sudo does not quite make sense

Know your round numbers or how to get 2^X with bash

Since I haven't written anything valuable for a long time and still have no ideas how to fix it, here is an example of how bash can actually help you quickly get values of two to the power of something. So, here we go

pg@dana:~$ for i in {1..100}; do calc "2^$i" | xargs echo; done
2
4
8
16
32
64
128
256
512
1024
2048
4096
8192
16384
32768
65536
<...>
1267650600228229401496703205376

Just in case you want to get to the bottom of it, this mini-script uses:
-- my favorite calc application (package name apcalc)
-- cycles (for ... ; do... ; done)
-- ranges ({1..100})
-- redirection with xargs ( | xargs echo)

Enjoy your Linux!

PS: 'Round numbers' in relation to 2^X is actually an inside joke from the times when I couldn't afford to rent my own flat and had to share

Some Examples of Bash for Use in Test

Time has come to finally write something of technical nature, not just another advice on how others should work to make me happy. So here is a cheatsheet for a tester who spends at least some of her time with nix console. For obvious reasons it wasn't my intention to cover everything, so please take it just as a memory refresher (or a source of ideas it you find it useful).

NB: It is assumed that as long as you understand what man is, you are fine (use it if my explanation is not enough).