Whamcloud - gitweb
windows porting: add private lnet tag to b_winnt_port branch
[fs/lustre-release.git] / lustre-iokit / stats-collect / gather_stats_everywhere.sh
1 #!/bin/sh
2
3 #########################################################################
4 # gather_stats_everywhere:
5 # script on a selection of nodes and collect all the results into a single
6 # tar ball
7 #
8 # Copyright (c) 2007 - Cluster File Systems, Inc.
9 #########################################################################
10
11 error() {
12         echo "ERROR: $0: $@"
13 }
14
15 warning() {
16         echo "WARNING: $@"
17 }
18
19 info () {
20         if [ ${PRINT_INFO_MSGS} -gt 0 ]
21         then
22                 echo "INFO: $@"
23         fi
24 }
25
26 debug () {
27         if [ ${PRINT_DEBUG_MSGS} -gt 0 ]
28         then
29                 echo "DEBUG: $@"
30         fi
31 }
32
33 usage() {
34         printf $"Usage: gather_stats_everywhere [-help] config_file [start|stop|cleanup] <log_name>\n"
35         if [ x$1 = x-h ]
36         then
37                  printf $"
38 The distribution script will run on a single node.  It is parameterised 
39 with a set of target node names.  It may assume ssh/scp to these node 
40 names works without requiring a password.  It will run in 2 modes...
41
42 gather_stats_everywhere config_file start
43
44 ...will copy the script to /tmp everywhere described in
45 config_file running on all the target hosts.  And...
46
47 gather_stats_everywhere config_file stop log_name
48
49 ...will stop script running on all the hosts it started on and collect 
50 all the individual stats files into a single compressed tarball if the log_name is
51 provided.
52
53 The config file is just a list of shell variable assignments that can be
54 customised. 
55
56 Serveral variables must be set in the config file
57
58 Targets: the nodes where run the script.
59 "
60                  exit 0
61         else
62                  exit 1
63         fi
64 }
65
66 options=`getopt -o h --long help:: -- "$@"`
67
68 if [ $? -ne 0 ]
69 then 
70         usage
71 fi
72
73 eval set -- "$options"
74
75 while true
76 do
77         case "$1" in
78                 -h)
79                         usage -h ;;
80                 --help)
81                         usage -h ;;
82                 --)
83                         shift
84                         break ;;
85         esac
86 done
87
88 if [ $# != 2 -a $# != 3 ] ; then
89         usage
90 fi
91
92 CONFIG=$1
93 OPTION=$2
94 shift
95 shift
96
97 GLOBAL_TIMESTAMP=""
98
99 if [ ! -r $CONFIG ]; then
100         error "Config_file: $CONFIG does not exist "
101         exit 1
102 fi
103
104 . $CONFIG
105
106 if [ -z "$SCRIPT" ]; then
107         error "SCRIPT in ${CONFIG} is empty"
108         exit 1
109 fi      
110
111 if [ -z "$TARGETS" ]; then
112         error "TARGETS in ${CONFIG} is empty"
113         exit 1
114 fi
115
116 #check nodes accessiable 
117 Check_nodes_available() {
118         local NODES_NOT_AVAILABLE=""
119
120         debug "Entering Check_nodes_available()"
121     
122         for TARGET in $TARGETS; do
123                 if ! ping -c 1 -w 3 $TARGET > /dev/null; then 
124                         NODES_NOT_AVAILABLE=$NODES_NOT_AVAILABLE$TARGET
125                 fi
126         done
127     
128         if [ -z "$NODES_NOT_AVAILABLE" ]; then
129                 debug "Check_nodes_available() returning 0 (success - all nodes available)"
130                 return 0
131         fi
132
133         error "Check_nodes_available: these nodes are not available (did not respond to pings): ${NODES_NOT_AVAILABLE}"
134         debug "Check_nodes_available() returning with errors"
135         
136         return 1
137 }
138
139 if ! Check_nodes_available;  then 
140         error "not all the nodes are available"
141         exit 1
142 fi
143
144 #
145 # returns 1 if copies of lstats are found running on any of the $TARGETS nodes
146 #
147 Nodes_are_not_clean() {
148         local DIRTY_NODES=""
149
150         debug "Entering Nodes_are_not_clean()"
151     
152         # check whether there are running threads on the targets
153         for TARGET in $TARGETS; do
154                 ps_str=`$DSH $TARGET "ps aux | grep -v grep | grep ${SCRIPT}-${TARGET}"`
155                 if [ -n "$ps_str" ]; then
156                         DIRTY_NODES="${DIRTY_NODES} ${TARGET}"
157                 fi
158         done
159
160         if [ -n "$DIRTY_NODES" ]; then
161                 debug "Nodes_are_not_clean() returning 1"
162                 return 1
163         fi
164
165         debug "Nodes_are_not_clean() returning 0"
166         return 0 
167 }
168
169 Clean_nodes() {
170
171         debug "Entering Clean_nodes()"
172     
173         #
174         # if debugging is enabled, show lists of lstats processes
175         # still running on the target nodes before the clean operation
176         #
177         if [ ${PRINT_DEBUG_MSGS} -gt 0 ]
178         then
179                 for TARGET in $TARGETS; do
180                         debug "List of processes which need to be cleaned up on ${TARGET}:"
181                         $DSH $TARGET "ps aux | grep -v grep | grep ${SCRIPT}-${TARGET}"
182                         debug "List of pids which need to be cleaned up on ${TARGET}:"
183                         $DSH $TARGET "ps aux | grep ${SCRIPT}-${TARGET} | grep -v grep | ${AWK} '{ print \$2 }'"
184                 done
185         fi
186     
187         #
188         # do the actual cleanup
189         # kill any old lstats processes still running on the target nodes
190         #
191         for TARGET in $TARGETS; do
192             
193                 ps_str=`$DSH $TARGET "ps aux | grep -v grep | grep ${SCRIPT}-${TARGET}"`
194                 if [ -n "$ps_str" ]; then
195                         debug "cleaning node ${TARGET}"
196                         $DSH $TARGET "ps aux | grep ${SCRIPT}-${TARGET} | grep -v grep | ${AWK} '{ print \$2 }' | ${XARGS} kill"
197                 fi
198         done
199
200         debug "Leaving Clean_nodes()"
201         return 0 
202 }
203
204 copy_target_script() {
205         local target=$1
206
207         debug "Entering copy_target_script()"
208     
209         #copy alex's run scripts to the target
210         copy_cmd="$DCP $SCRIPT ${USER}${target}:$TMP/${SCRIPT}-${target}"
211         ${copy_cmd} 1>/dev/null 2>&1 
212         if [ ${PIPESTATUS[0]} != 0 ]; then
213                 echo "copy command failed: ${copy_cmd}" 2>&1
214                 debug "Leaving copy_target_script() (error return)"
215                 return 1
216         fi
217         
218         echo "$SCRIPT copied to ${USER}${target} (into $TMP)"
219         debug "Leaving copy_target_script() (normal return)"
220         return 0
221 }
222
223 start_target_script() {
224         local target=$1
225
226         debug "Entering start_target_script()"
227     
228         if ! copy_target_script $target; then
229                 echo "copy_target_script $target failed." 2>&1
230                 debug "Leaving start_target_script() (error return)"
231                 return 1
232         fi
233
234         #run the script on the target
235         $DSH ${USER}${target} "VMSTAT_INTERVAL=${VMSTAT_INTERVAL} \
236                       SDIO_INTERVAL=${SDIO_INTERVAL} \
237                       SERVICE_INTERVAL=${SERVICE_INTERVAL} \
238                       BRW_INTERVAL=${BRW_INTERVAL}         \
239                       JBD_INTERVAL=${JBD_INTERVAL}         \
240                       IO_INTERVAL=${IO_INTERVAL}           \
241                       MBALLOC_INTERVAL=${MBALLOC_INTERVAL} \
242                       sh ${TMP}/${SCRIPT}-${target} start  \
243                       1> /dev/null 2>/dev/null </dev/null"
244
245         if [ ${PIPESTATUS[0]} != 0 ]; then
246                 echo "Start the ${SCRIPT} on ${target} failed"
247                 debug "Leaving start_target_script() (error return)"
248                 return 1
249         fi
250                 
251         echo "Start the ${SCRIPT} on ${target} success"
252         debug "Leaving start_target_script() (normal return)"
253         return 0
254 }
255
256 stop_target_script() {
257         local target=$1
258
259         debug "Entering stop_target_script()"
260     
261         #stop the target script first
262         $DSH ${USER}${target} "sh ${TMP}/${SCRIPT}-${target} stop" 1>/dev/null 2>&1
263         if [ ${PIPESTATUS[0]} != 0 ]; then
264                 echo  "stop the collecting stats script on ${target} failed"
265                 debug "Leaving stop_target_script() (error return)"
266                 return 1 
267         else    
268                 echo  "stop the collecting stats script on ${target} success"
269         fi
270
271         #remove those tmp file
272         $DSH ${USER}${target} "rm -rf $TMP/${SCRIPT}-${target}" 1>/dev/null 2>&1
273         echo "cleanup ${target} tmp file after stop "
274         
275         debug "Leaving stop_target_script() (normal return)"
276         return 0
277 }
278
279 #
280 # create a unique timestamp-based name which we can use for
281 # naming files on all the $TARGET nodes.
282 #
283 # By creating one timestamp here on the master node, we avoid
284 # the problem of clock skew on the $TARGET nodes causing them
285 # to use different filenames than we expect (if their clocks are
286 # different from the clock on this node)
287 #
288 generate_timestamp() {
289         if [ "X${GLOBAL_TIMESTAMP}" = "X" ]
290         then
291                 export GLOBAL_TIMESTAMP=`date +%F-%H.%M.%S`
292                 debug "Global Timestamp Created: ${GLOBAL_TIMESTAMP}"
293         fi
294 }
295
296 fetch_target_log() {
297         generate_timestamp
298         local target=$1
299         local date=${GLOBAL_TIMESTAMP}
300         local target_log_name="stats-${target}-${date}"
301
302         echo "Getting log: ${target_log_name}.tar.gz from ${target}"
303         $DSH ${USER}${target} "sh ${TMP}/${SCRIPT}-${target} fetch " \
304                       > $TMP/${target_log_name}.tar.gz
305         echo "Got log: ${target_log_name}.tar.gz from ${target}"
306
307         echo "Moving $TMP/${target_log_name}.tar.gz to $TMP/$log_name"
308         mv $TMP/${target_log_name}.tar.gz $TMP/$log_name
309 }
310
311 fetch_log() {
312         generate_timestamp
313         local log_name=${GLOBAL_TIMESTAMP}
314         local stat_tar_name=$1
315         local -a pids_array
316         local -a clients_array
317
318         debug "Entering fetch_log()"
319     
320         if ! mkdir -p $TMP/$log_name ; then
321                 error "can not mkdir $log_name"
322                 exit 1
323         fi
324
325         #retrive the log_tarball from remote nodes background 
326         local n=0
327         for TARGET in $TARGETS; do
328                 (fetch_target_log ${TARGET}) & 
329                 pids_array[$n]=$!
330                 clients_array[$n]=$TARGET
331                 
332                 debug "fetch_log: spawned fetch_target_log process for ${TARGET} pid ${pids_array[$n]}"
333                 let n=$n+1
334         done
335         
336         local num_pids=$n
337
338         #Waiting log fetch finished
339         for ((n=0; $n < $num_pids; n++)); do
340                 debug "fetch_log(): waiting for pid ${pids_array[$n]}"
341                 wait ${pids_array[$n]}
342                 
343                 #
344                 # TODO: add check of exit status from wait()
345                 #
346         done
347
348         #compress the log tarball
349         cmd="$TAR ${stat_tar_name} $TMP/${log_name}"
350         echo "Creating compressed tar file ${stat_tar_name} from log files in  $TMP/${log_name}"
351         ${cmd} 1>/dev/null 2>&1 
352         if [ ${PIPESTATUS[0]} == 0 ]; then
353                 echo "removing temporary directory $TMP/${log_name}"
354                 rm -rf $TMP/${log_name}
355         else
356                 echo "Compressed logfiles are in $TMP/${stat_tar_name}"
357         fi
358         
359         debug "Leaving fetch_log()"
360 }
361
362 stop_targets_script() {
363         local -a pids_array
364         local -a clients_array
365         local n=0
366         
367         debug "Entering stop_targets_script()"
368         
369         for TARGET in $TARGETS; do
370                 (stop_target_script ${TARGET}) &
371                 pids_array[$n]=$!
372                 clients_array[$n]=$TARGET
373                 let n=$n+1
374         done
375         local num_pids=$n
376         
377         #Waiting log fetch finished
378         for ((n=0; $n < $num_pids; n++)); do
379                 if ! wait ${pids_array[$n]}; then
380                         echo "${clients_array[$n]}: can not stop stats collect"
381                 fi
382         done
383         
384         debug "Leaving stop_targets_script()"
385         
386 }
387
388 gather_start() {
389         local -a pids_array
390         local -a clients_array
391         local n=0
392         
393         debug "Entering gather_start()"
394         
395         #check whether the collect scripts already start in some targets 
396
397         Nodes_are_not_clean
398         ret=$?
399     
400         if [ $ret -gt 0 ]
401         then
402             warning "$SCRIPT already running in some targets, attempting cleanup..."
403             
404             Clean_nodes
405             
406             Nodes_are_not_clean
407             ret=$?
408             
409             if [ $ret -gt 0 ]
410             then
411                 error "$SCRIPT automatic cleanup attempt failed."
412                 error "$SCRIPT Please make sure lstats is no longer running on target nodes and try again."
413                 debug "Error return from gather_start()"
414                 return 1
415             fi
416         fi
417         
418         for TARGET in $TARGETS; do
419                 (start_target_script ${TARGET}) &
420                 pids_array[$n]=$!
421                 clients_array[$n]=$TARGET
422                 let n=$n+1
423         done
424         
425         local num_pids=$n
426
427         local RC=0      
428         #Waiting log fetch finished
429         for ((n=0; $n < $num_pids; n++)); do
430                 if ! wait ${pids_array[$n]}; then
431                         echo "${clients_array[$n]}: can not start stats collect"
432                         let RC=$RC+1
433                 fi
434         done
435
436         if [ $RC != 0 ]; then
437                 stop_targets_script
438         fi
439         
440         debug "Leaving gather_start()"
441 }
442
443 gather_stop() {
444         log=$1
445
446         debug "Entering gather_stop()"
447     
448         if [ -n "$log" ]; then
449                 fetch_log $log
450         fi
451         
452         stop_targets_script
453         
454         debug "Leaving gather_stop()"
455 }
456
457 get_end_line_num()
458 {
459         local log_name=$1
460
461         ln=`grep -n snapshot_time ${log_name}  | awk -F":" '{ln=$1;} END{print ln;}'`
462         total_ln=`wc ${log_name} | awk '{print $1}'`                    
463
464         local endlen=$((${total_ln} - ${ln}))
465         echo $endlen
466 }
467
468 get_csv()
469 {
470         local logdir=$1
471         local statf=$2
472
473         local statf_name=`basename ${statf}`
474         type_name=`echo ${statf_name} | awk -F "." '{print $3}'`
475         stat_name=`head -n 1 ${statf} | awk '{print $4}'`
476         stat_type=`head -n 1 ${statf} | awk '{print $1}'`
477
478         #currently, it can only analyse client application log
479         if [ "$stat_type" != "client" ]; then
480                 error "can not analyse ${statf} ......."
481                 exit 1
482         fi
483
484         #create the header
485         echo "${node_name}_${type_name}, ${stat_name}" \
486                         >> $logdir/analyse_${type_name}.csv
487
488         #get total stats collection
489         end_len=`get_end_line_num ${statf}`
490         if [ $end_len != 1 -a $end_len != 0 ]; then
491                 if [ "$type_name" != "osc-rpc_stats" ]; then
492                         tail -n $end_len ${statf} | awk '{print $1 "," $2}' \
493                                 >> $logdir/analyse_${type_name}.csv
494                 else
495                         tail -n $end_len ${statf} |                     \
496                         awk  '/^[[:digit:]]/{print $1","$2","$6}        \
497                               /^page/{print "page per rpc,read,write"}  \
498                               /^rpcs/{print "rpcs,read,write"}          \
499                               /^offset/{print "offset, read,write"}'    \
500                         >> $logdir/analyse_${type_name}.csv
501                 fi
502         fi
503 }
504
505 gather_analyse()
506 {
507         local log_tarball=$1
508         local option=$2
509
510         debug "Entering gather_analyze()"
511     
512         #validating option
513         if [ -z "$log_tarball" -o -r "$option" ]; then
514                 usage;
515         fi
516
517         if [ ! -r $log_tarball ]; then
518                 error " not exist $log_tarball "
519                 return 1
520         fi
521
522         shift
523
524         local date=`date +%F-%H-%M`
525         local logdir="analyse-${date}" 
526
527         mkdir -p ${TMP}/${logdir}
528         mkdir -p ${TMP}/${logdir}/tmp
529
530         $UNTAR $log_tarball -C ${TMP}/${logdir}/tmp 1>/dev/null 2>&1
531         for log_file in `find $TMP/$logdir/tmp`; do
532                 if test -f $log_file; then
533                         #get the node name
534                         local file_name=`basename ${log_file}`
535                         node_name=`echo ${file_name} | awk -F "-" '{print $2}'`
536                         echo "analysing the sublog ...$log_file"
537                         mkdir -p ${TMP}/${logdir}/${node_name}
538                         mkdir -p ${TMP}/${logdir}/${node_name}/tmp
539
540                         $UNTAR $log_file -C ${TMP}/${logdir}/${node_name}/tmp 1>/dev/null 2>&1
541                         for statf in `find ${TMP}/${logdir}/${node_name}/tmp`; do
542                                 if test -f $statf ; then
543                                         if [ "$option" == "csv" ]; then
544                                                 get_csv "$TMP/$logdir/${node_name}" "$statf"
545                                         fi
546                                 fi
547                         done
548                         rm -rf ${TMP}/${logdir}/${node_name}/tmp
549                 fi
550         done
551
552         rm -rf ${TMP}/${logdir}/tmp
553         $TAR ${TMP}/${logdir}.tar.gz ${TMP}/${logdir} 1>/dev/null 2>&1
554
555         echo "create analysed tarball ${TMP}/${logdir}.tar.gz"
556         
557         debug "Leaving gather_analyze()"
558 }
559
560 case $OPTION in
561         start) gather_start ;;
562         stop)  gather_stop $@;;
563         analyse) gather_analyse $@;;
564         *) error "Unknown option ${OPTION}" ; exit 1
565 esac