Peteris Krumin wrote some articles explaining every one-liner in the two files, and these articles are absolutely worth a comprehensive read. It took Peteris some months to finish the explaination, thanks a lot to his dedicated work!

The Awk One-Liners Explained article

• Part One: File spacing, Numbering and calculations
• Part Two: Text conversion and substitution
• Part Three: Selective printing or deleting of certain lines
• Part Four: String creation, array creation and update on selective printing of certain lines

The Sed One-Liners Explained article

• Part One: File spacing, Numbering and Text conversion and substitution
• Part Two: Selective printing of certain lines
• Part Three: Selective deletion of certain lines and Special applications

When multiple instances of one script running, it’s easy to cause problems. I’ve ever seen that about 350 instances of a status checking script running there without doing anything, but eat lots of system resource.

So it’s an important feature for your scripting work, and you might have faced similar issues already in cron jobs, system monitoring scripts or system backup procedures.

Well, how can we get rid of such problems?

The idea is simple, the first instance of the script should open a file, and lock it to get rid of the second instance. Therefore when the consequent instances try to run and lock the file, it will fails. Here we show three examples on how to lock a script in Shell, Python and Perl. If you have any questions on implementing, please dont hesitate to ask questions at our scripting support forum.

How can we create a lock file in Shell?

An example looks like this:

# This is to examine whether the lockfile existed
[ -f "${0}.lock" ] && exit -1
# Create the lock file
lockfile ${0}.lock
# Your code goes here!
# Release the lock file manually
rm -f ${0}.lock

Please keep in mind that as we use relative path for the lockfile here, we need to make sure when creating and deleting the lock file, we’re in the same working directory.

How can we create a lock file in Perl?

With the help of Fcntl, it’s easy. By default Fcntl is installed on common linux distributions. An example looks like this:

use Fcntl ':flock'; # import LOCK_* constants
INIT{
open  *{0}
or die "What!? $0:$!";
flock *{0}, LOCK_EX|LOCK_NB
or die "$0 is already running somewhere!n";
}

It has one disadvantage that on at least one system and on one version of Perl (AS635 on Win2k) you won’t see any error message or script generated message as Perl will fail (quietly!?) if you try to run the script while it is already running.

Understanding the distinction between your shell types, profile files and shell rc files is important because when you apply modifications to your system you need to know where  to set variables in order to make sure that they can be initialized as expected.

Let’s give a quick answer for this topic which covers the exact difference between the two shells.

When you login your system and see the command line prompt, it’s a login shell, and it executes these files in order:

• /etc/profile
• ~/.bash_profile
• ~/.bashrc
• /etc/bashrc

A non-login shell will only execute the two files in order:

• /etc/bashrc
• ~/.bashrc

So what’s a non-login shell?
When issuing this command:

$ ssh joseph@howto.admon.org ‘uptime’

you will gain a non-login shell at the remote side howto.admon.org. when you type bash after login, your new shell is also a non-login shell.

Now, you may have a clear answer to a common system administration question: How can I properly apply a new system variable like JAVA_HOME?

It’s better to set it in /etc/bashrc other than /etc/profile. Addtionally, there’re better choice. If you prefer to make your system clean and tidy, it’s suggested to create single config files in /etc/profile.d, the point is all these file would be initialized by both login shell and non-login shell:

$ grep profile /etc/profile /etc/bashrc
/etc/profile:# /etc/profile
/etc/profile:for i in /etc/profile.d/*.sh ; do
/etc/bashrc:# Environment stuff goes in /etc/profile
/etc/bashrc:        for i in /etc/profile.d/*.sh; do

NOTE: The suffix of the file name should be “.sh”, e.g. /etc/profile.d/java.sh

Further readings: learnlinux.tsf.org.za and linuxquestions.org ]]> http://www.admon.org/difference-between-login-shell-and-non-login-shell/feed/ 7 http://www.admon.org/sysadmin-tips-bash-shell-shortcuts/ http://www.admon.org/sysadmin-tips-bash-shell-shortcuts/#comments Tue, 08 Sep 2009 08:02:12 +0000 joseph http://blog.admon.org/?p=49

Bash, which is the default shell in Linux contains a whole lot of key bindings which makes it really easy to use  The most commonly used shortcuts are listed below:
Original version of this post is here at blogspot.com.

____________CTRL Key Bound_____________
Ctrl + a – Jump to the start of the line
Ctrl + b – Move back a char
Ctrl + c – Terminate the command
Ctrl + d – Delete from under the cursor
Ctrl + e – Jump to the end of the line
Ctrl + f – Move forward a char
Ctrl + k – Delete to EOL
Ctrl + l – Clear the screen
Ctrl + r – Search the history backwards
Ctrl + R – Search the history backwards with multi occurrence
Ctrl + u – Delete backward from cursor
Ctrl + xx – Move between EOL and current cursor position
Ctrl + x @ – Show possible hostname completions
Ctrl + z – Suspend/ Stop the command

____________ALT Key Bound___________
Alt + < – Move to the first line in the history
Alt + > – Move to the last line in the history
Alt + ? – Show current completion list
Alt + * – Insert all possible completions
Alt + / – Attempt to complete filename
Alt + . – Yank last argument to previous command
Alt + b – Move backward
Alt + c – Capitalize the word
Alt + d – Delete word
Alt + f – Move forward
Alt + l – Make word lowercase
Alt + n – Search the history forwards non-incremental
Alt + p – Search the history backwards non-incremental
Alt + r – Recall command
Alt + t – Move words around
Alt + u – Make word uppercase
Alt + back-space – Delete backward from cursor

—————- More Special Keybindings ——————-

Here “2T” means Press TAB twice

$ 2T – All available commands(common)
$ (string)2T – All available commands starting with (string)
$ /2T – Entire directory structure including Hidden one
$ 2T – Only Sub Dirs inside including Hidden one
$ *2T – Only Sub Dirs inside without Hidden one
$ ~2T – All Present Users on system from “/etc/passwd”
$ $2T – All Sys variables
$ @2T – Entries from “/etc/hosts”
$ =2T – Output like ls or dir

But sometimes if the symlink files got broken, how can we find the dead ones out?

Here’s a simple script does the work well:

[planet@admon ~]$ cat check-dead-softlink.sh

[planet@admon ~]$ cat check-dead-softlink.sh
#!/bin/bash
#
# joseph from http://planet.admon.org
# This script is intended to find broken symlinks for
# a list of specified directories.

[ $# -eq 0 ] && directorys=`pwd` || directorys=$@

linkchk()
{
        for file in $1/*
        do
        [ -L "$file" -a ! -e "$file" ] && echo "$file"
        [ -d "$file" ]&&linkchk $file
        done
}

for directory in $directorys
do
    [ -d $directory ] && linkchk $directory
  else
    echo "$directory is not a directory, request ignored!"
    echo "Usage: $0 dir1 dir2 dir3 ..."
  fi
done
exit 0

The output from an examining case:

[planet@admon ~]$ cd shell/
[planet@admon shell]$ ls -l symbol
lrwxrwxrwx 1 root root 28 Oct 10 15:19 symbol -> /home/oracle/hldataadmin.dmp
[planet@admon shell]$ cat symbol
cat: symbol: No such file or directory
[planet@admon shell]$ cd ..
[planet@admon ~]$ ./check-dead-softlink.sh shell
"shell/symbol"

If you face any issues on this script, please dont hesitate to create a post here at Linux Scripting at Forum.Admon.org