source: trunk/web/addons/job_monarch/overview.php @ 311

Last change on this file since 311 was 311, checked in by bastiaans, 15 years ago

web/addons/job_monarch/overview.php:

  • remove multibyte string dependant routines
  • Property svn:keywords set to Id
File size: 20.4 KB
Line 
1<?php
2/*
3 *
4 * This file is part of Jobmonarch
5 *
6 * Copyright (C) 2006  Ramon Bastiaans
7 *
8 * Jobmonarch is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * Jobmonarch is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
21 *
22 * SVN $Id: overview.php 311 2007-04-18 07:17:10Z bastiaans $
23 */
24
25global $GANGLIA_PATH, $clustername, $tpl, $filter, $cluster, $get_metric_string, $cluster_url, $sh;
26global $hosts_up, $m, $start, $end, $filterorder, $COLUMN_REQUESTED_MEMORY, $COLUMN_QUEUED, $COLUMN_NODES, $hostname, $piefilter;
27
28$data_gatherer = new DataGatherer( $clustername );
29
30$tpl->assign( "clustername", $clustername );
31
32if( $JOB_ARCHIVE )
33        $tpl->assign( "cluster_url", rawurlencode($clustername) );
34
35$data_gatherer->parseXML();
36
37$heartbeat = $data_gatherer->getHeartbeat();
38$jobs = $data_gatherer->getJobs();
39$gnodes = $data_gatherer->getNodes();
40$cpus = $data_gatherer->getCpus();
41
42function setupFilterSettings() {
43        global $tpl, $filter, $clustername, $piefilter;
44
45        $filter_image_url = "";
46
47        $tpl->gotoBlock( "_ROOT" );
48
49        foreach( $filter as $filtername => $filtervalue ) {
50                $tpl->assign( "f_".$filtername, $filtervalue );
51                $filter_image_url .= "&$filtername=$filtervalue";
52        }
53
54        $tpl->assign( "clusterimage", "./image.php?c=".rawurlencode($clustername)."&view=big-clusterimage".$filter_image_url );
55        $tpl->assign( "f_order", $filterorder );
56
57        if( array_key_exists( "id", $filter ) )
58                $piefilter = 'id';
59        else if( array_key_exists( "user", $filter ) )
60                $piefilter = 'user';
61        else if( array_key_exists( "queue", $filter ) )
62                $piefilter = 'queue';
63
64        $pie = drawPie();
65        $tpl->assign("pie", $pie );
66}
67
68function timeToEpoch( $time ) {
69
70        $time_fields = explode( ':', $time );
71
72        if( count($time_fields) == 3 ) {
73
74                $hours = $time_fields[0];
75                $minutes = $time_fields[1];
76                $seconds = $time_fields[2];
77
78        } else if( count($time_fields) == 2 ) {
79
80                $hours = 0;
81                $minutes = $time_fields[0];
82                $seconds = $time_fields[1];
83
84        } else if( count($time_fields) == 1 ) {
85
86                $hours = 0;
87                $minutes = 0;
88                $seconds = $time_fields[0];
89        }
90
91        $myepoch = intval( $seconds + (intval( $minutes * 60 )) + (intval( $hours * 3600 )) );
92
93        return $myepoch;
94}
95
96//function makeDate( $time ) {
97//      return strftime( "%a %d %b %Y %H:%M:%S", $time );
98//}
99
100function colorRed( $color ) {
101        return substr( $color, 0, 2 );
102}
103function colorGreen( $color ) {
104        return substr( $color, 2, 2 );
105}
106function colorBlue( $color ) {
107        return substr( $color, 4, 2 );
108}
109
110function colorDiffer( $first, $second ) {
111
112        // Make sure these two colors differ atleast 50 R/G/B
113        $min_diff = 50;
114
115        $c1r = hexDec( colorRed( $first ) );
116        $c1g = hexDec( colorGreen( $first ) );
117        $c1b = hexDec( colorBlue( $first ) );
118
119        $c2r = hexDec( colorRed( $second ) );
120        $c2g = hexDec( colorGreen( $second ) );
121        $c2b = hexDec( colorBlue( $second ) );
122
123        $rdiff = ($c1r >= $c2r) ? $c1r - $c2r : $c2r - $c1r;
124        $gdiff = ($c1g >= $c2g) ? $c1g - $c2g : $c2g - $c1g;
125        $bdiff = ($c1b >= $c2b) ? $c1b - $c2b : $c2b - $c1b;
126
127        if( $rdiff >= $min_diff or $gdiff >= $min_diff or $bdiff >= $min_diff )
128                return TRUE;
129        else
130                return FALSE;
131}
132
133function randomColor( $known_colors ) {
134
135        $start = "004E00";
136       
137        $start_red = colorRed( $start );
138        $start_green = colorGreen( $start );
139        $start_blue = colorBlue( $start );
140       
141        $end = "FFFFFF";
142
143        $end_red = colorRed( $end );
144        $end_green = colorGreen( $end );
145        $end_blue = colorBlue( $end );
146
147        $change_color = TRUE;
148
149        while( $change_color ) {
150
151                $change_color = FALSE;
152
153                $new_red = rand( hexDec( $start_red ), hexDec( $end_red ) );
154                $new_green = rand( hexDec( $start_green ), hexDec( $end_green ) );
155                $new_blue = rand( hexDec( $start_blue ), hexDec( $end_blue ) );
156
157                $new = decHex( $new_red ) . decHex( $new_green ) . decHex( $new_blue );
158
159                foreach( $known_colors as $old )
160
161                        if( !colorDiffer( $new, $old ) )
162
163                                $change_color = TRUE;
164        }
165
166        // Whoa! Actually found a good color ;)
167        return $new;
168}
169
170function drawJobPie() {
171}
172
173function drawUserPie() {
174
175}
176
177function drawQueuePie() {
178
179}
180
181
182function drawPie() {
183
184        global $jobs, $gnodes, $piefilter, $filter;
185
186        $nodes = $gnodes;
187
188        if( isset($piefilter) ) 
189                $pie_args = "title=" . rawurlencode("Cluster ".$piefilter." usage");
190        else
191                $pie_args = "title=" . rawurlencode("Cluster queue usage");
192               
193        $pie_args .= "&size=250x150";
194
195        $queues = array();
196        $nr_jobs = count( $jobs );
197        $nr_nodes = count( $nodes );
198
199        $emptynodes = 0;
200
201        $job_weight = array();
202
203        foreach( $nodes as $node ) {
204
205                $myjobs = $node->getJobs();
206
207                if( count( $myjobs ) == 0 )
208                        $emptynodes++;
209        }
210        $used_nodes = $nr_nodes - $emptynodes;
211
212        $empty_percentage = ($emptynodes / $nr_nodes) * 100;
213        $job_percentage = 100 - $empty_percentage; 
214
215        $qcolors = array();
216        $color = randomColor( $qcolors );
217        $qcolors[] = $color;
218        $pie_args .= "&free=$empty_percentage,$color";
219
220        if( isset( $piefilter ) )
221                $filterpie = array();
222
223        foreach( $nodes as $node ) {
224
225                $node_jobs = $node->getJobs();
226                $nr_node_jobs = count( $node_jobs );
227                $myhost = $node->getHostname();
228
229                foreach( $node_jobs as $myjob ) {
230
231                        // Determine the weight of this job on the node it is running
232                        // - what percentage of the node is in use by this job
233                        //
234                        $job_weight[$myjob] = ( 100 / count( $node_jobs ) ) / 100;
235                        $qname = $jobs[$myjob][queue];
236
237                        if( isset($piefilter) ) {
238                                $countjob = 1;
239                                if( $piefilter == 'id' ) {
240                                        if( $myjob != $filter[$piefilter] )
241                                                $countjob = 0;
242                                } else if( $piefilter == 'user' ) {
243                                        if( $jobs[$myjob][owner] != $filter[$piefilter] )
244                                                $countjob = 0;
245                                } else {
246                                        if( $jobs[$myjob][$piefilter] != $filter[$piefilter] )
247                                                $countjob = 0;
248                                }
249
250                                if( $countjob ) {
251
252                                        if( !isset( $filterpie[$filter[$piefilter]] ) )
253                                                $filterpie[$filter[$piefilter]] = $job_weight[$myjob];
254                                        else
255                                                $filterpie[$filter[$piefilter]] = $filterpie[$filter[$piefilter]] + $job_weight[$myjob];
256                                } else {
257                                        if( !isset( $filterpie["other"] ) )
258                                                $filterpie["other"] = $job_weight[$myjob];
259                                        else
260                                                $filterpie["other"] = $filterpie["other"] + $job_weight[$myjob];
261
262                                }
263                               
264                        } else {
265
266                                if( !isset( $queues[$qname] ) )
267                                        $queues[$qname] = $job_weight[$myjob];
268                                else
269                                        $queues[$qname] = $queues[$qname] + $job_weight[$myjob];
270                        }
271                }
272        }
273
274        //$qcolors = array();
275        if( isset( $piefilter ) )
276                $graphvals = $filterpie;
277        else
278                $graphvals = $queues;
279
280        foreach( $graphvals as $name => $totalweight) {
281
282                $percentage = ( $totalweight / $used_nodes ) * $job_percentage;
283               
284                $color = randomColor( $qcolors );
285                $qcolors[] = $color;
286                $pie_args .= "&$name=$percentage,$color";
287        }
288        $pie = "../../pie.php?$pie_args";
289
290        return $pie;
291}
292
293
294function sortJobs( $jobs, $sortby, $sortorder ) {
295
296        $sorted = array();
297
298        $cmp = create_function( '$a, $b', 
299                "global \$sortby, \$sortorder;".
300
301                "if( \$a == \$b ) return 0;".
302
303                "if (\$sortorder==\"desc\")".
304                        "return ( \$a < \$b ) ? 1 : -1;".
305                "else if (\$sortorder==\"asc\")".
306                        "return ( \$a > \$b ) ? 1 : -1;" );
307
308        if( isset( $jobs ) && count( $jobs ) > 0 ) {
309
310                foreach( $jobs as $jobid => $jobattrs ) {
311
312                                $state = $jobattrs[status];
313                                $user = $jobattrs[owner];
314                                $queue = $jobattrs[queue];
315                                $name = $jobattrs[name];
316                                $req_cpu = $jobattrs[requested_time];
317                                $req_memory = $jobattrs[requested_memory];
318
319                                if( $state == 'R' )
320                                        $nodes = count( $jobattrs[nodes] );
321                                else
322                                        $nodes = $jobattrs[nodes];
323
324                                $ppn = (int) $jobattrs[ppn] ? $jobattrs[ppn] : 1;
325                                $cpus = $nodes * $ppn;
326                                $queued_time = (int) $jobattrs[queued_timestamp];
327                                $start_time = (int) $jobattrs[start_timestamp];
328                                $runningtime = $report_time - $start_time;
329
330                                switch( $sortby ) {
331                                        case "id":
332                                                $sorted[$jobid] = $jobid;
333                                                break;
334
335                                        case "state":
336                                                $sorted[$jobid] = $state;
337                                                break;
338
339                                        case "user":
340                                                $sorted[$jobid] = $user;
341                                                break;
342
343                                        case "queue":
344                                                $sorted[$jobid] = $queue;
345                                                break;
346
347                                        case "name":
348                                                $sorted[$jobid] = $name;
349                                                break;
350
351                                        case "req_cpu":
352                                                $sorted[$jobid] = timeToEpoch( $req_cpu );
353                                                break;
354
355                                        case "req_mem":
356                                                $sorted[$jobid] = $req_memory;
357                                                break;
358
359                                        case "nodes":
360                                                $sorted[$jobid] = $nodes;
361                                                break;
362
363                                        case "cpus":
364                                                $sorted[$jobid] = $cpus;
365                                                break;
366
367                                        case "queued":
368                                                $sorted[$jobid] = $queued_time;
369                                                break;
370
371                                        case "start":
372                                                $sorted[$jobid] = $start_time;
373                                                break;
374
375                                        case "runningtime":
376                                                $sorted[$jobid] = $runningtime;
377                                                break;
378
379                                        default:
380                                                break;
381
382                                }
383                }
384        }
385
386        //uasort( $sorted, $cmp );
387        if( $sortorder == "asc" )
388                arsort( $sorted );
389        else if( $sortorder == "desc" )
390                asort( $sorted );
391
392        return $sorted;
393}
394
395function makeOverview() {
396
397        global $jobs, $nodes, $heartbeat, $clustername, $tpl;
398        global $sortorder, $sortby, $filter, $sh, $hc, $m;
399        global $cluster_url, $get_metric_string, $host_url, $metrics;
400        global $start, $end, $reports, $gnodes, $default_showhosts;
401        global $COLUMN_QUEUED, $COLUMN_REQUESTED_MEMORY, $COLUMN_NODES, $hostname;
402        $metricname = $m;
403
404        $tpl->assign("sortorder", $sortorder );
405        $tpl->assign("sortby", $sortby );
406
407        $sorted_jobs = sortJobs( $jobs, $sortby, $sortorder );
408
409        $even = 1;
410
411        $used_jobs = 0;
412        $used_cpus = 0;
413        $used_nodes = 0;
414
415        $queued_jobs = 0;
416        $queued_nodes = 0;
417        $queued_cpus = 0;
418
419        $total_nodes = 0;
420        $total_cpus = 0;
421        $total_jobs = 0;
422
423        $all_used_nodes = array();
424        $total_used_nodes = array();
425
426        $running_name_nodes = array();
427
428        $running_nodes = 0;
429        $running_jobs = 0;
430        $running_cpus = 0;
431
432        $avail_nodes = count( $gnodes );
433        $avail_cpus = cluster_sum("cpu_num", $metrics);
434
435        $view_cpus = 0;
436        $view_jobs = 0;
437        $view_nodes = 0;
438
439        $all_nodes = 0;
440        $all_jobs = 0;
441        $all_cpus = 0;
442
443        $view_name_nodes = array();
444
445        if( $COLUMN_REQUESTED_MEMORY ) {
446                $tpl->newBlock( "column_header_req_mem" );
447        }
448
449        if( $COLUMN_NODES ) {
450                $tpl->newBlock( "column_header_nodes" );
451        }
452
453        if( $COLUMN_QUEUED ) {
454                $tpl->newBlock( "column_header_queued" );
455        }
456
457        $last_displayed_job = null;
458
459        foreach( $sorted_jobs as $jobid => $sortdec ) {
460
461                $report_time = $jobs[$jobid][reported];
462
463                if( $jobs[$jobid][status] == 'R' )
464                        $nodes = count( $jobs[$jobid][nodes] );
465                else if( $jobs[$jobid][status] == 'Q' )
466                        $nodes = $jobs[$jobid][nodes];
467
468                $ppn = (int) $jobs[$jobid][ppn] ? $jobs[$jobid][ppn] : 1;
469                $cpus = $nodes * $ppn;
470
471                if( $report_time == $heartbeat ) {
472
473                        $display_job = 1;
474
475                        if( $jobs[$jobid][status] == 'R' ) {
476                                foreach( $jobs[$jobid][nodes] as $tempnode ) {
477                                        $all_used_nodes[] = $tempnode;
478                                }
479                        }
480
481                        $used_cpus += $cpus;
482
483                        if( $jobs[$jobid][status] == 'R' ) {
484                                $running_cpus += $cpus;
485                                $running_jobs++;
486
487                                $found_node_job = 0;
488
489                                foreach( $jobs[$jobid][nodes] as $tempnode ) {
490                                        $running_name_nodes[] = $tempnode;
491
492                                        if( isset( $hostname ) && $hostname != '' ) {
493                                                //$filter[host] = $hostname;
494
495                                                $domain_len = 0 - strlen( $jobs[$jobid][domain] );
496                                                $hostnode = $tempnode;
497                                                if( substr( $hostnode, $domain_len ) != $jobs[$jobid][domain] ) {
498                                                        $hostnode = $hostnode. '.'. $jobs[$jobid][domain];
499                                                }
500
501                                                if( $hostname == $hostnode ) {
502                                                        $found_node_job = 1;
503                                                        $display_job = 1;
504                                                } else if( !$found_node_job ) {
505                                                        $display_job = 0;
506                                                }
507                                        }
508                                }
509                        }
510
511                        if( $jobs[$jobid][status] == 'Q' ) {
512                                if( isset( $hostname ) && $hostname != '' )
513                                        $display_job = 0;
514
515                                $queued_cpus += $cpus;
516                                $queued_nodes += $nodes;
517                                $queued_jobs++;
518                        }
519
520                        foreach( $filter as $filtername=>$filtervalue ) {
521
522                                if( $filtername == 'id' && $jobid != $filtervalue )
523                                        $display_job = 0;
524                                else if( $filtername == 'state' && $jobs[$jobid][status] != $filtervalue )
525                                        $display_job = 0;
526                                else if( $filtername == 'queue' && $jobs[$jobid][queue] != $filtervalue )
527                                        $display_job = 0;
528                                else if( $filtername == 'user' && $jobs[$jobid][owner] != $filtervalue )
529                                        $display_job = 0;
530                        }
531
532                        if( $display_job ) {
533
534                                $tpl->newBlock("node");
535                                $tpl->assign( "clustername", $clustername );
536                                $tpl->assign("id", $jobid );
537
538                                $last_displayed_job = $jobid;
539
540                                $tpl->assign("state", $jobs[$jobid][status] );
541
542                                $fullstate = '';
543                                if( $jobs[$jobid][status] == 'R' ) {
544                                        $fullstate = "Running";
545                                } else if( $jobs[$jobid][status] == 'Q' ) {
546                                        $fullstate = "Queued";
547                                }
548
549                                $tpl->assign("fullstate", $fullstate );
550                               
551                                $tpl->assign("user", $jobs[$jobid][owner] );
552                                $tpl->assign("queue", $jobs[$jobid][queue] );
553
554                                $fulljobname = $jobs[$jobid][name];
555                                $shortjobname = '';
556
557                                $tpl->assign("fulljobname", $fulljobname );
558
559                                $fulljobname_fields     = explode( ' ', $fulljobname );
560
561                                $capjobname     = 0;
562
563                                if( strlen( $fulljobname_fields[0] ) > 10 )
564                                        $capjobname     = 1;
565
566                                if( $capjobname ) {
567                                        $tpl->newBlock("jobname_hint_start");
568                                        $tpl->gotoBlock("node");
569
570                                        $shortjobname = substr( $fulljobname, 0, 10 ) . '..';
571                                } else {
572                                        $shortjobname = $fulljobname;
573                                }
574                               
575                                $tpl->assign("name", $shortjobname );
576
577                                if( $capjobname ) {
578                                        $tpl->newBlock("jobname_hint_end");
579                                        $tpl->gotoBlock("node");
580                                }
581
582                                $domain = $jobs[$jobid][domain];
583                                $tpl->assign("req_cpu", makeTime( timeToEpoch( $jobs[$jobid][requested_time] ) ) );
584
585                                if( $COLUMN_REQUESTED_MEMORY ) {
586                                        $tpl->newBlock( "column_req_mem" );
587                                        $tpl->assign( "req_memory", $jobs[$jobid][requested_memory] );
588                                        $tpl->gotoBlock( "node" );
589                                }
590
591
592                                if( $COLUMN_QUEUED ) {
593                                        $tpl->newBlock( "column_queued" );
594                                        $tpl->assign( "queued", makeDate( $jobs[$jobid][queued_timestamp] ) );
595                                        $tpl->gotoBlock( "node" );
596                                }
597
598                                $ppn = (int) $jobs[$jobid][ppn] ? $jobs[$jobid][ppn] : 1;
599                                $cpus = $nodes * $ppn;
600                                $tpl->assign("nodes", $nodes );
601                                $tpl->assign("cpus", $cpus );
602                                $start_time = (int) $jobs[$jobid][start_timestamp];
603                                $job_start = $start_time;
604
605                                $view_cpus += $cpus;
606                                $view_jobs++;
607
608                                if( $jobs[$jobid][status] == 'R' ) {
609                                        foreach( $jobs[$jobid][nodes] as $tempnode )
610                                                $view_name_nodes[] = $tempnode;
611
612                                        if( $COLUMN_NODES ) {
613                                                $tpl->newBlock( "column_nodes" );
614                                                $mynodehosts = array();
615                                                foreach( $jobs[$jobid][nodes] as $mynode ) {
616                                                        $myhost_href = "./?c=".$clustername."&h=".$mynode.".".$jobs[$jobid][domain];
617                                                        $mynodehosts[] = "<A HREF=\"".$myhost_href."\">".$mynode."</A>";
618                                                }
619                                                $nodes_hostnames = implode( " ", $mynodehosts );
620                                                $tpl->assign( "nodes_hostnames", $nodes_hostnames );
621                                                $tpl->gotoBlock( "node" );
622                                        }
623                                } else if( $jobs[$jobid][status] == 'Q' ) {
624                                        $view_nodes += (int) $jobs[$jobid][nodes];
625                                }
626
627                                if( $even ) {
628
629                                        $tpl->assign("nodeclass", "even");
630                                        $even = 0;
631                                } else {
632
633                                        $tpl->assign("nodeclass", "odd");
634                                        $even = 1;
635                                }
636
637                                if( $start_time ) {
638
639                                        $runningtime = makeTime( $report_time - $start_time );
640                                        $job_runningtime = $report_time - $start_time;
641                                        $tpl->assign("started", makeDate( $start_time ) );
642                                        $tpl->assign("runningtime", $runningtime );
643                                }
644                        }
645                }
646        }
647        $all_used_nodes = array_unique( $all_used_nodes );
648        $view_name_nodes = array_unique( $view_name_nodes );
649        $running_name_nodes = array_unique( $running_name_nodes );
650
651        $used_nodes = count( $all_used_nodes );
652        $view_nodes += count( $view_name_nodes );
653        $running_nodes += count( $running_name_nodes );
654
655        $total_nodes = $queued_nodes + $running_nodes;
656        $total_cpus = $queued_cpus + $running_cpus;
657        $total_jobs = $queued_jobs + $running_jobs;
658
659        $tpl->assignGlobal("avail_nodes", $avail_nodes );
660        $tpl->assignGlobal("avail_cpus", $avail_cpus );
661
662        $tpl->assignGlobal("queued_nodes", $queued_nodes );
663        $tpl->assignGlobal("queued_jobs", $queued_jobs );
664        $tpl->assignGlobal("queued_cpus", $queued_cpus );
665
666        $tpl->assignGlobal("total_nodes", $total_nodes );
667        $tpl->assignGlobal("total_jobs", $total_jobs );
668        $tpl->assignGlobal("total_cpus", $total_cpus );
669
670        $tpl->assignGlobal("running_nodes", $running_nodes );
671        $tpl->assignGlobal("running_jobs", $running_jobs );
672        $tpl->assignGlobal("running_cpus", $running_cpus );
673
674        $tpl->assignGlobal("used_nodes", $used_nodes );
675        $tpl->assignGlobal("used_jobs", $used_jobs );
676        $tpl->assignGlobal("used_cpus", $used_cpus );
677
678        $free_nodes = $avail_nodes - $running_nodes;
679        $free_cpus = $avail_cpus - $running_cpus;
680
681        $tpl->assignGlobal("free_nodes", $free_nodes );
682        $tpl->assignGlobal("free_cpus", $free_cpus );
683
684        $tpl->assignGlobal("view_nodes", $view_nodes );
685        $tpl->assignGlobal("view_jobs", $view_jobs );
686        $tpl->assignGlobal("view_cpus", $view_cpus );
687
688        $tpl->assignGlobal("report_time", makeDate( $heartbeat));
689
690        if( intval($view_jobs) == 1 and $start_time )
691                if( $last_displayed_job != null )
692                        $filter[id] = $last_displayed_job;
693
694        makeHeader( 'overview' );
695        setupFilterSettings();
696
697        if( intval($view_jobs) == 1 and $start_time ) {
698
699                $tpl->newBlock( "showhosts" );
700
701                # Present a width list
702                $cols_menu = "<SELECT NAME=\"hc\" OnChange=\"toga_form.submit();\">\n";
703
704
705                $hostcols = ($hc) ? $hc : 4;
706
707                foreach(range(1,25) as $cols) {
708                        $cols_menu .= "<OPTION VALUE=$cols ";
709                        if ($cols == $hostcols)
710                                $cols_menu .= "SELECTED";
711                        $cols_menu .= ">$cols\n";
712                }
713                $cols_menu .= "</SELECT>\n";
714
715                //$tpl->assign("cluster", $clustername);
716                $tpl->assign("metric","$metricname $units");
717                $tpl->assign("id", $filter[id]);
718                # Host columns menu defined in header.php
719                $tpl->assign("cols_menu", $cols_menu);
720
721                $showhosts = isset($sh) ? $sh : $default_showhosts;
722                //if( !$showhosts) $showhosts = $default_showhosts;
723                $tpl->assign("checked$showhosts", "checked");
724
725                if( $showhosts ) {
726                        //-----
727
728                        if( !isset($start) ) $start="jobstart";
729                        if( !isset($stop) ) $stop="now";
730                        //$tpl->assign("start", $start);
731                        //$tpl->assign("stop", $stop);
732
733                        $sorted_hosts = array();
734                        $hosts_up = $jobs[$filter[id]][nodes];
735
736                        $r = intval($job_runningtime * 1.25);
737
738                        $jobrange = ($job_runningtime < 3600) ? -3600 : -$r ;
739                        $jobstart = $report_time - $job_runningtime;
740
741                        if ($reports[$metricname])
742                                $metricval = "g";
743                        else
744                                $metricval = "m";
745                               
746                        foreach ($hosts_up as $host ) {
747
748                                $domain_len = 0 - strlen( $domain );
749                                if( substr( $host, $domain_len ) != $domain ) {
750                                        $host = $host. '.'.$domain;
751                                }
752                                $cpus = $metrics[$host]["cpu_num"][VAL];
753                                if (!$cpus) $cpus=1;
754                                $load_one  = $metrics[$host]["load_one"][VAL];
755                                $load = ((float) $load_one)/$cpus;
756                                $host_load[$host] = $load;
757                                $percent_hosts[load_color($load)] += 1;
758                                if ($metricname=="load_one")
759                                        $sorted_hosts[$host] = $load;
760                                else
761                                        $sorted_hosts[$host] = $metrics[$host][$metricname][VAL];
762                        }
763                        switch ($sort) {
764                                case "descending":
765                                        arsort($sorted_hosts);
766                                        break;
767                                case "by hostname":
768                                        ksort($sorted_hosts);
769                                        break;
770                                default:
771                                case "ascending":
772                                        asort($sorted_hosts);
773                                        break;
774                        }
775
776                        //$sorted_hosts = array_merge($down_hosts, $sorted_hosts);
777
778                        # First pass to find the max value in all graphs for this
779                        # metric. The $start,$end variables comes from get_context.php,
780                        # included in index.php.
781                        list($min, $max) = find_limits($sorted_hosts, $metricname);
782
783                        # Second pass to output the graphs or metrics.
784                        $i = 1;
785                        foreach ( $sorted_hosts as $host=>$value  ) {
786                                $tpl->newBlock ("sorted_list");
787                                //$host = $host. '.'.$domain;
788                                $host_url = rawurlencode($host);
789                                $cluster_url = rawurlencode($clustername);
790
791                                $textval = "";
792                                //printf("host = %s, value = %s", $host, $value);
793                                //echo "$host: $value, ";
794                                $val = $metrics[$host][$metricname];
795                                $class = "metric";
796                                $host_link="\"../../?c=$cluster_url&h=$host_url&r=job&jr=$jobrange&js=$jobstart\"";
797
798                                if ($val[TYPE]=="timestamp" or $always_timestamp[$metricname]) {
799                                        $textval = date("r", $val[VAL]);
800                                } elseif ($val[TYPE]=="string" or $val[SLOPE]=="zero" or $always_constant[$metricname] or ($max_graphs > 0 and $i > $max_graphs )) {
801                                        $textval = "$val[VAL] $val[UNITS]";
802                                } else {
803                                        $load_color = load_color($host_load[$host]);
804                                        $graphargs = ($reports[$metricname]) ? "g=$metricname&" : "m=$metricname&";
805                                        $graphargs .= "z=small&c=$cluster_url&h=$host_url&l=$load_color" ."&v=$val[VAL]&r=job&jr=$jobrange&js=$jobstart";
806                                        if( $max > 0 ) {
807
808                                                $graphargs .= "&x=$max&n=$min";
809                                        }
810                                }
811                                if ($textval) {
812                                        $cell="<td class=$class>".  "<b><a href=$host_link>$host</a></b><br>".  "<i>$metricname:</i> <b>$textval</b></td>";
813                                } else {
814                                        $cell="<td><a href=$host_link>".  "<img src=\"../../graph.php?$graphargs\" ".  "alt=\"$host\" border=0></a></td>";
815                                }
816
817                                $tpl->assign("metric_image", $cell);
818                                if (! ($i++ % $hostcols) )
819                                         $tpl->assign ("br", "</tr><tr>");
820                        }
821                }
822//---
823        }
824}
825?>
Note: See TracBrowser for help on using the repository browser.