UNIX for Advanced & Expert Users

Hello All,

We have a very old system at hand in which there are hundreds of shell scripts that use other shell scripts, all on the same server. There are several that are not used at all as well. In short, it's an unmanaged system thats been lying around for many years, and it needs to be cleaned up.

One of the ways I've been thinking of is to build a script that shows the plan of execution, given a seed script. For example, if a script A calls B and C and B calls M and N, then the given a seed of A, the script produces something like:

A
++B
++++M
++++N
++C

The intent of course is to identify which scripts are in use, and which ones are not.

Alternatively, I have considered checking the access timestamp using the -a option of ls to identify the script not being used for a long time. However, it does not give me the results I need.

Of course, I welcome other solutions to this problem and your experience if you've faced similar situations.

Create an exported variable in the top level script A and in every script that A calls expand that variable by appending a plus to it. Echo that variable in every called script to display its level in the call sequence. Repeat this process for every called script.

A

Code:

#!/usr/bin/ksh

export NUM_OF_PLUS="+"

# script A calls scripts B and C at this step
B
C

B

Code:

#!/usr/bin/ksh

export NUM_OF_PLUS="+"

# display the called level of this script
echo ${NPLUS}$0

# script B calls scripts M and N at this step
M
N

C

Code:

#!/usr/bin/ksh

export NUM_OF_PLUS="+"

# display the called level of this script
echo ${NPLUS}$0

M

Code:

#!/usr/bin/ksh

export NUM_OF_PLUS="+"

# display the called level of this script
echo ${NPLUS}$0

N

Code:

#!/usr/bin/ksh

export NUM_OF_PLUS="+"

# display the called level of this script
echo ${NPLUS}$0

Now executing A displays the calling heirarchy of the scripts.
$ A
A
++B
+++M
+++N
++C

Thanks shamrock..

The basic objective here is to find out which scripts are being used and which ones are not, by having a trace of execution without actually executing (bypassing the control structures as well). With the solution you suggest, I need to have a prior knowledge of the same, to modify the scripts accordingly. Morever, there are hundreds fo scripts that are actually executed, and several hundred just lying around, with no purpose, which I want to weed out.

What I'm thinking is to build a recursive parser for shell script, but since I'm not at a liberty of time, I need to explore other solutions, even if they produce approximate results.

Can you write a single script that will examine all of your scripts one at a time and create an output file where each record has two fields, the first field is the name of the script, and the second is the name of the called script. So that if script A calls B and C, the output would look like:
A B
A C

When you are finished you can sort by field two and get a where used list.
Second thought.
Copy all the scripts into a single directory:

list=`ls *`
for entry in $list
do
grep $entry * >>output
done

I've been working all night so if it doesn't work oh well.

How about this:

Add the following line to every single shell script (at the top, right after the shebang line, in case the script halts execution somewhere due to a conditional):

Code:

echo -e "$0\t$(date)" >> scripts.log

This way, you'll end up with a log file which will show you which scripts were executed and when. This doesn't directly address your problem of finding out which scripts call which, but you can do that with some fancy grep work. And in any case, I believe the whole point of that was to make sure you weren't leaving unused scripts out there, and this will identify all used scripts.

Note: the $0 in a bash script will be replaced with the name of the current command. If you run that from the command line (outside of a script), it will simply return "bash."

ShawnMilo

Thanks jgt and ShawnMilo.

jgt: he solution will work, and I'm exploring this option.

ShawnMilo: Your solution is similar to shamrock's conceptually. I'm slightly wary of this solution because it'll involve a lot of manual work. Thanks anyway!

At this stage I'm also exploring the option of actually executing the code and capturing trace (only to EXEC and FORKs) on unix level, to see what scripts get exec'd, which will in effect tell me what commands got executed by shell(s)

I again thank everyone for reading and specially to those who took out time to reply.

Have a custom script call all the others. Then continuously track the process tree of the custom script.
Check man ps for tree options. Minimally have something like

Code:

   ps -ejH
   ps axjf