grep gives us options that we can use with it. Here’s a list of some of the most useful:

·          -h   if you search more than one file at a time, the results contain the name of the file 

              from which the string was found. This option turns off that feature, giving you only 

              the lines without the file name.   

·          -n   precedes each line with the line number where it was found  

·          -i    tells grep to ignore case so that it treats "the" and "The" as the same word  

·          -l     displays a list of files that contain the string  

·          -w    restricts the search to whole words only   

#shellmariachi

:0<Return> or 1G move cursor to first line in file

:n<Return> or nG move cursor to line n

:$<Return> or G move cursor to last line in file

^f move forward one screen

^b move backward one screen

Undo:

* u UNDO WHATEVER YOU JUST DID; a simple toggle

Show line numbers:

:set number

Turn off showing line numbers:

:set nonumber

Source:

http://www.cs.colostate.edu/helpdocs/vi.html

The above source pointed too is really exhaustive. Take a print-out and stick it to your cubicle wall.

#shellmariachi

${#array[*]} substitutes the number of elements in array.

Now this is really important, “pay attention 007″:

${parameter#pattern} if the pattern given is found at start of the contents of parameter, it deletes the matching characters and substitutes the remainder. The smallest possible match is deleted. The pattern is expanded to produce a pattern just as in filename expansion

${parameter##pattern} same as above but deletes the largest possible match at the start of parameter.

${parameter%pattern} same as above but deletes the smallest match at the end of parameter.

${parameter%%pattern} same as above but deletes the largest match at the end of parameter.

Example: “${0##*/}” in a shell script means:

This is meant to remove all characters before the last “/ “from the path entered to invoke the script, leaving only the name of the script.

## matches the longest match from start of the string, and looks for the last occurrence of “/” from beginning, if only # was used it would match the shortest match from start of the string, looking for the first occurrence of “/” from beginning.

#shellmariachi

${parameter:=word} substitutes the contents of the parameter but if it is empty or undefined, it sets parameter equal to the word and substitutes word.

${parameter:?message} substitutes the contents of the parameter, but if it is empty or undefined, aborts the script and gives the message as a final error. Message might contain unquoted spaces.

${parameter:+word} if parameter is not empty, it substitutes the word; otherwise it substitutes nothing. The value of parameter does not change.

#shellmariachi

find / -name gibberish

To search for a file containing data with a string “gibberish” in it, in a directory or subdirectories, lets say under current directory (.)

find . | xargs grep gibberish

I didn’t have much time today for a longer post

#shellmariachi

:<<’COMMENTBLOCK’

commented code goes here

COMMENTBLOCK

You can replace COMMENTBLOCK with any string. But remember to put the quotes around the ‘COMMENTBLOCK’ in the starting line of the block.

We are utilizing a here document for this purpose.

Source:

http://tldp.org/LDP/abs/html/here-docs.html#CBLOCK1

Alternatively you can use if-test

COMMENT_BLOCK=

if [ $COMMENT_BLOCK ]; then

commented code goes here

fi

Source:

http://tldp.org/LDP/abs/html/assortedtips.html

A short tip, but useful none-the-less as there is no provisioned syntax for this; its hacks like above that can be used to serve as comment blocks

#shellmariachi

Sorry, this post has nothing to do with Shell scripting

Strategy: Add a new drive, format it into few partitions, mount individual directories onto these new partitions, transfer data from old drive to new drive.

Note: The steps defined below are very critical. Be very careful with what you type; commands like fdisk, mkfs have potential to ruin your system. Also, remove old data from old drive, only after ensuring its safe and correctly copied in its new place.

Step 1:

Login to your machine, and do a

ls /dev/sd* (SCSI drive) or /dev/hd* (IDE drive)

Note down the entries.

Mine had something like

/dev/sda /dev/sda1 /dev/sda2

Step 2:

In case of VM Image login and add a new virtual drive (my case). In case of hardware, I guess ask a hardware expert/IT person to do that.

Step 3:

Login to your machine, and do a

ls /dev/sd* or /dev/hd* again

I saw that a /dev/sdb was there additionally (You can’t check for a new drive doing a “ls -lt”, as all drives listed carry same date-time, the time when the table was last updated).

Step 4:

Partition this new drive. I planned to host my /opt, /tmp and “/p4-data” (location where my p4 client syncs data) directories, onto the 3 different partitions on the new drive.

You will need to either login as root or do a sudo with each command for this.

Do a /sbin/fdisk or just fdisk (if sbin is in path) on the new drive

/sbin/fdisk /dev/sdb

You will get

Command (m for help):

Here fdisk is waiting for a command; you can type m to get a list of options.

Enter n to create a new partition.

Command action
e extended
p primary partition (1-4)

Enter p. Choose defaults for Partition number and First cylinder (default is 1 for new drive). Now decide in what percentages you want to divide your disk. I decided into 40-40-20, and had 1044 cylinders available. So when prompted to enter Last cylinder I entered 400. Alternatively you can specify in bytes, kb or MB, see fdisk man.

Repeat this for the other partitions, giving appropriate values for First and Last cylinders.

At last, we’ll display the partition table. Again, write down all of this information—especially the block sizes of your new partitions. Enter p when prompted to print the partition table.

For me finally sizing up was 1-400 (sdb1), 401-800(sdb2), 801-1044(sdb3).

Finally, we use the w command to write the changes to disk and exit fdisk. Alternatively, to quit fdisk without saving any changes, use the q command.

Step 5:

Reboot, for changes to be updated (to be on safe side). Now we format the partitions with type ext3.

/sbin/mkfs -t ext3 /dev/sdb1

Repeat for other partitions.

Step 6:

Now create a new directory (say “newhd”) and mount it on one of the partitions.

mount /dev/sdb1 /newhd

Now back-up (recursively copy) your data you want to free up on old drive (in my case data on /opt, /p4-data) onto this new directory.

Step 7:

Rename the old directories (/opt, /p4-data, /tmp)

mv /opt /opt.old

mv /p4-data /p4-data.old

mv /tmp /tmp.old

Recreate these directories

mkdir /opt

mkdir /p4-data

mkdir /tmp (SEE ADDITIONAL STEP 10 for this new /tmp)

Step 8: Edit /etc/fstab and add lines like the following:

/dev/sdb1 /p4-data ext3 defaults 2 1

/dev/sdb2 /opt ext3 defaults 2 1

/dev/sdb3 /tmp ext3 defaults 2 1

On a separate note: The last two digits mean this, in case you are wondering:

Column 5: Adjusts the archiving schedule for the partition (used by dump).

Column 6: Indicates the order in which the fsck utility will scan the partitions for errors when the computer powers on.

Do a “mount -a” to mount according to the new fstab.

Now transfer the backed-up data on /newhd (mounted on sdb1 so you can leave the data meant for /p4-data behind) to appropriate places (the newly created directories mounted on new partitions).

Unmount the backed-up directory as:

umount /newhd

Step 9:

You are done now. Check the new mount points using “mount” and “df -k” commands. Check that you have your data on the new directories. Reboot and check if everything is preserved.

For me it was:

$mount
/dev/mapper/VolGroup00-LogVol00 on / type ext3 (rw)
…
/dev/sda1 on /boot type ext3 (rw)
…
/dev/sdb1 on /p4-data type ext3 (rw)
/dev/sdb2 on /opt type ext3 (rw)
/dev/sdb3 on /tmp type ext3 (rw)
…

Now you can delete the data from the old directories (like /opt.old) . This should free up space on old drive. Also you can delete the /newhd directory as its not needed now. (Ensure you unmounted it and its empty).

Step 10:

This is an extra step required for /tmp directory you created in Step 7

chmod 1777 /tmp

This sets the sticky bit on tmp directory, its permissions should look like this “drwxrwxrwt”

On a separate note:

Its good to mount /tmp on a new partition. Why? “Often-modified files contribute heavily to fragmentation. One of the best ways to contain fragmentation is to store often-modified files on their own partition. That way, the other partitions are unaffected by the fragmentation caused by the heavily modified files.” * See the 4th source below.

Note:
In case you find any fault with the steps mentioned, when you try, please do let me know, to make the corrections in this article. I wrote it by recollecting what I had done, while following a bunch of resources on the web.

Sources:

http://www.ibm.com/developerworks/library/l-partplan.html#h6

http://www.debianhelp.co.uk/newharddisk.htm

http://www.tdl.com/~netex/linux-doc-project/install-guide/node73.html

* http://www.funtoo.org/en/articles/linux/partitioning/2/

#shellmariachi

Variable

Description

$0

The name of the command being executed. For shell scripts, this is the path with which it was invoked.

$n

These variables correspond to the arguments with which a script was invoked. Here n is a positive decimal number corresponding to the position of an argument (the first argument is $1; the second argument is $2, and so on).

$#

The number of arguments supplied to a script.

$*

All the arguments are double quoted.

$@

All the arguments are individually double quoted.

$?

The exit status of the last command executed.

$$

The process number of the current shell. For shell scripts, this is the process ID under which they are executing.

$!

The process number of the last background command.

#shellmariachi

export JAVA_HOME=/opt/java_1.5

export BEA_JAVA_HOME=BEA_HOME/jrockit1.5.0_06

– For a csh/tcsh shell, type:

setenv JAVA_HOME=/opt/java_1.5

setenv BEA_JAVA_HOME=BEA_HOME/jrockit1.5.0_06

For Windows:

set JAVA_HOME=C:\java_1.5

set BEA_JAVA_HOME=BEA_HOME\jrockit1.5.0_06

Got it? Its “export” sh/bash/ksh. “setenv” on csh/tcsh and “set” on Windows!

#shellmariachi

Little intro as this is the first post. This blog would deal with simple “learnings” of shell scripting, as I go forth in my new job profile where I shall be using shell scripting often. I was maintaining these facts to act as quick reference in a word document, as I have a poor memory. Then I thought why not start a blog and maybe other people can “make benefit” from it too

So here we go.

Now there is this “set -e” option. This tells bash to exit the script if any statement returns a non-zero (false) value. You should put it at the beginning of the script as:

#! /bin/bash -e

or set -e

or set -o errexit

The “make benefit” is that you can avoid the situation of cumulative effect of errors becoming harder to debug.

However you can’t check $? shell variable as code won’t get there if it isn’t zero.

You can turn off this error checking for portions in the script by using:

set +e

command 1

command 2

command 3

set -e

Also, you can use :

command||true

if you want that this particular command’s non-zero return value shouldn’t exit the script.

Also, bash takes the status of last statement in a pipeline. false|true is true. To avoid this you can use:

set -o pipefail

So long!

# shellmariachi