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

Last change on this file since 517 was 517, checked in by bastiaans, 14 years ago

web/addons/job_monarch/overview.php,
web/addons/job_monarch/templates/overview.tpl:

  • make "Unavailable" a block that only shows if the info is available
  • Property svn:keywords set to Id
File size: 24.2 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 517 2008-03-08 20:40:26Z 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;
27global $longtitle, $title, $range;
28
29$tpl->assign( "clustername", $clustername );
30
31if( $JOB_ARCHIVE )
32{
33        $tpl->assign( "cluster_url", rawurlencode($clustername) );
34}
35
36$ds             = new DataSource();
37$myxml_data     = $ds->getData();
38
39$data_gatherer  = new DataGatherer( $clustername );
40$data_gatherer->parseXML( $myxml_data );
41
42$heartbeat      = $data_gatherer->getHeartbeat();
43$jobs           = $data_gatherer->getJobs();
44$gnodes         = $data_gatherer->getNodes();
45$cpus           = $data_gatherer->getCpus();
46$use_fqdn       = $data_gatherer->getUsingFQDN();
47
48function setupFilterSettings() 
49{
50
51        global $tpl, $filter, $clustername, $piefilter, $data_gatherer, $myxml_data, $filterorder;
52
53        $filter_image_url = "";
54
55        $tpl->gotoBlock( "_ROOT" );
56
57        foreach( $filter as $filtername => $filtervalue ) 
58        {
59                $tpl->assign( "f_".$filtername, $filtervalue );
60
61                $filter_image_url       .= "&$filtername=$filtervalue";
62        }
63
64        session_start();
65
66        unset( $_SESSION["data"] );
67        $_SESSION["data"]       = &$myxml_data;
68
69        $ic                     = new ClusterImage( $myxml_data, $clustername );
70
71        $ic->setBig();
72        $ic->setNoimage();
73        $ic->draw();
74
75        $tpl->assign( "clusterimage", "./image.php?". session_name() . "=" . session_id() ."&c=".rawurlencode($clustername)."&view=big-clusterimage".$filter_image_url );
76
77        //$tpl->assign( "clusterimage_width", $ic->getWidth() );
78        //$tpl->assign( "clusterimage_height", $ic->getHeight() );
79
80        $tpl->newBlock( "node_clustermap" );
81        $tpl->assign( "node_area_map", $ic->getImagemapArea() );
82        $tpl->gotoBlock( "_ROOT" );
83
84        $tpl->assign( "f_order", $filterorder );
85
86        if( array_key_exists( "id", $filter ) ) 
87        {
88                $piefilter = 'id';
89        } 
90        else if( array_key_exists( "user", $filter ) ) 
91        {
92                $piefilter = 'user';
93        } 
94        else if( array_key_exists( "queue", $filter ) ) 
95        {
96                $piefilter = 'queue';
97        }
98
99        $pie    = drawPie();
100
101        $tpl->assign("pie", $pie );
102}
103
104function timeToEpoch( $time ) 
105{
106        $time_fields    = explode( ':', $time );
107
108        if( count( $time_fields ) == 3 ) 
109        {
110                $hours          = $time_fields[0];
111                $minutes        = $time_fields[1];
112                $seconds        = $time_fields[2];
113
114        } 
115        else if( count( $time_fields ) == 2 ) 
116        {
117                $hours          = 0;
118                $minutes        = $time_fields[0];
119                $seconds        = $time_fields[1];
120
121        } 
122        else if( count( $time_fields ) == 1 ) 
123        {
124                $hours          = 0;
125                $minutes        = 0;
126                $seconds        = $time_fields[0];
127        }
128
129        $myepoch        = intval( $seconds + (intval( $minutes * 60 )) + (intval( $hours * 3600 )) );
130
131        return $myepoch;
132}
133
134function colorRed( $color ) 
135{
136        return substr( $color, 0, 2 );
137}
138
139function colorGreen( $color ) 
140{
141        return substr( $color, 2, 2 );
142}
143
144function colorBlue( $color ) 
145{
146        return substr( $color, 4, 2 );
147}
148
149function colorDiffer( $first, $second ) 
150{
151        // Make sure these two colors differ atleast 50 R/G/B
152        $min_diff = 50;
153
154        $c1r    = hexDec( colorRed( $first ) );
155        $c1g    = hexDec( colorGreen( $first ) );
156        $c1b    = hexDec( colorBlue( $first ) );
157
158        $c2r    = hexDec( colorRed( $second ) );
159        $c2g    = hexDec( colorGreen( $second ) );
160        $c2b    = hexDec( colorBlue( $second ) );
161
162        $rdiff  = ($c1r >= $c2r) ? $c1r - $c2r : $c2r - $c1r;
163        $gdiff  = ($c1g >= $c2g) ? $c1g - $c2g : $c2g - $c1g;
164        $bdiff  = ($c1b >= $c2b) ? $c1b - $c2b : $c2b - $c1b;
165
166        if( $rdiff >= $min_diff or $gdiff >= $min_diff or $bdiff >= $min_diff ) 
167        {
168                return TRUE;
169
170        } 
171        else 
172        {
173                return FALSE;
174        }
175}
176
177function randomColor( $known_colors ) 
178{
179        // White (000000) would be invisible
180        $start          = "004E00";
181       
182        $start_red      = colorRed( $start );
183        $start_green    = colorGreen( $start );
184        $start_blue     = colorBlue( $start );
185       
186        $end            = "FFFFFF";
187
188        $end_red        = colorRed( $end );
189        $end_green      = colorGreen( $end );
190        $end_blue       = colorBlue( $end );
191
192        $change_color   = TRUE;
193
194        while( $change_color ) 
195        {
196                $change_color   = FALSE;
197
198                $new_red        = rand( hexDec( $start_red ), hexDec( $end_red ) );
199                $new_green      = rand( hexDec( $start_green ), hexDec( $end_green ) );
200                $new_blue       = rand( hexDec( $start_blue ), hexDec( $end_blue ) );
201
202                $new            = decHex( $new_red ) . decHex( $new_green ) . decHex( $new_blue );
203
204                foreach( $known_colors as $old )
205                {
206                        if( !colorDiffer( $new, $old ) )
207                        {
208                                $change_color = TRUE;
209                        }
210                }
211        }
212
213        // Whoa! Actually found a good color ;)
214        return $new;
215}
216
217// Code these some day
218function drawJobPie() { }
219
220function drawUserPie() { }
221
222function drawQueuePie() { }
223
224
225function drawPie() 
226{
227        global $jobs, $gnodes, $piefilter, $filter, $metrics;
228
229        $nodes          = $gnodes;
230
231        if( isset($piefilter) ) 
232        {
233                $pie_args       = "title=" . rawurlencode("Cluster ".$piefilter." usage");
234        } 
235        else 
236        {
237                $pie_args       = "title=" . rawurlencode("Cluster queue usage");
238        }
239
240        $pie_args       .= "&size=250x150";
241
242        $queues         = array();
243        $nr_jobs        = count( $jobs );
244        $nr_nodes       = count( $nodes );
245
246        $nr_cpus        = cluster_sum("cpu_num", $metrics);
247
248        $empty_cpus     = 0;
249        $used_cpus      = 0;
250
251        $job_weight     = array();
252
253        foreach( $nodes as $node ) 
254        {
255                $myjobs         = $node->getJobs();
256                $myhost         = $node->getHostname();
257                $node_cpus      = $metrics[$myhost]["cpu_num"][VAL];
258                $job_cpu        = 0;
259
260                foreach( $myjobs as $myjob ) 
261                {
262                        $job_cpu        += (int) $jobs[$myjob][ppn] ? $jobs[$myjob][ppn] : 1;
263                }
264
265                $node_freecpu   = $node_cpus - $job_cpu;
266
267                $empty_cpus     += $node_freecpu;
268        }
269
270        $empty_cpus             = ( $empty_cpus >= 0 ) ? $empty_cpus : 0;
271        $used_cpus              = $nr_cpus - $empty_cpus;
272
273        $empty_percentage       = ($empty_cpus / $nr_cpus) * 100;
274
275        $qcolors                = array();
276        $color                  = randomColor( $qcolors );
277        $qcolors[]              = $color;
278        $pie_args               .= "&free=$empty_percentage,$color";
279
280        if( isset( $piefilter ) )
281        {
282                $filterpie = array();
283        }
284
285        foreach( $nodes as $node )
286        {
287                $node_jobs      = $node->getJobs();
288                $nr_node_jobs   = count( $node_jobs );
289                $myhost         = $node->getHostname();
290                $node_cpus      = $metrics[$myhost]["cpu_num"][VAL];
291
292                foreach( $node_jobs as $myjob )
293                {
294                        $job_cpu                = (int) $jobs[$myjob][ppn] ? $jobs[$myjob][ppn] : 1;
295
296                        // Determine the weight of this job
297                        // - what percentage of the cpus is in use by this job
298                        //
299                        $job_weight[$myjob]     = ( $job_cpu / $nr_cpus );
300
301
302                        if( isset( $piefilter ) ) {
303
304                                $countjob = 1;
305
306                                if( $piefilter == 'id' )
307                                {
308                                        if( $myjob != $filter[$piefilter] )
309                                        {
310                                                $countjob = 0;
311                                        }
312                                }
313                                else if( $piefilter == 'user' )
314                                {
315                                        if( $jobs[$myjob][owner] != $filter[$piefilter] )
316                                        {
317                                                $countjob = 0;
318                                        }
319                                }
320                                else
321                                {
322                                        if( $jobs[$myjob][$piefilter] != $filter[$piefilter] )
323                                        {
324                                                $countjob = 0;
325                                        }
326                                }
327
328                                if( $countjob )
329                                {
330
331                                        if( !isset( $filterpie[$filter[$piefilter]] ) )
332                                        {
333                                                $filterpie[$filter[$piefilter]] = $job_weight[$myjob];
334                                        }
335                                        else
336                                        {
337
338                                                $filterpie[$filter[$piefilter]] = $filterpie[$filter[$piefilter]] + $job_weight[$myjob];
339                                        }
340                                }
341                                else
342                                {
343                                        if( !isset( $filterpie["other"] ) )
344                                        {
345                                                $filterpie["other"] = $job_weight[$myjob];
346                                        }
347                                        else
348                                        {
349                                                $filterpie["other"] = $filterpie["other"] + $job_weight[$myjob];
350                                        }
351
352                                }
353                               
354                        }
355                        else
356                        {
357
358                                $qname          = $jobs[$myjob][queue];
359
360                                if( !isset( $queues[$qname] ) )
361                                {
362                                        $queues[$qname] = $job_weight[$myjob];
363                                }
364                                else
365                                {
366                                        $queues[$qname] = $queues[$qname] + $job_weight[$myjob];
367                                }
368                        }
369                }
370        }
371
372        if( isset( $piefilter ) )
373        {
374                $graphvals = $filterpie;
375        }
376        else
377        {
378                $graphvals = $queues;
379        }
380
381        foreach( $graphvals as $name => $totalweight) 
382        {
383                $percentage     = ( $totalweight * 100 );
384               
385                $color          = randomColor( $qcolors );
386                $qcolors[]      = $color;
387                $pie_args       .= "&$name=$percentage,$color";
388        }
389        $pie = "../../pie.php?$pie_args";
390
391        return $pie;
392}
393
394
395function sortJobs( $jobs, $sortby, $sortorder ) 
396{
397        $sorted = array();
398
399        $cmp    = create_function( '$a, $b', 
400                "global \$sortby, \$sortorder;".
401
402                "if( \$a == \$b ) return 0;".
403
404                "if (\$sortorder==\"desc\")".
405                        "return ( \$a < \$b ) ? 1 : -1;".
406                "else if (\$sortorder==\"asc\")".
407                        "return ( \$a > \$b ) ? 1 : -1;" );
408
409        if( isset( $jobs ) && count( $jobs ) > 0 ) 
410        {
411                foreach( $jobs as $jobid => $jobattrs ) 
412                {
413                                $state          = $jobattrs[status];
414                                $user           = $jobattrs[owner];
415                                $queue          = $jobattrs[queue];
416                                $name           = $jobattrs[name];
417                                $req_cpu        = $jobattrs[requested_time];
418                                $req_memory     = $jobattrs[requested_memory];
419
420                                if( $state == 'R' )
421                                {
422                                        $nodes = count( $jobattrs[nodes] );
423                                }
424                                else
425                                {
426                                        $nodes = $jobattrs[nodes];
427                                }
428
429                                $ppn            = (int) $jobattrs[ppn] ? $jobattrs[ppn] : 1;
430                                $cpus           = $nodes * $ppn;
431                                $queued_time    = (int) $jobattrs[queued_timestamp];
432                                $start_time     = (int) $jobattrs[start_timestamp];
433                                $runningtime    = $report_time - $start_time;
434
435                                switch( $sortby ) 
436                                {
437                                        case "id":
438                                                $sorted[$jobid] = $jobid;
439                                                break;
440
441                                        case "state":
442                                                $sorted[$jobid] = $state;
443                                                break;
444
445                                        case "user":
446                                                $sorted[$jobid] = $user;
447                                                break;
448
449                                        case "queue":
450                                                $sorted[$jobid] = $queue;
451                                                break;
452
453                                        case "name":
454                                                $sorted[$jobid] = $name;
455                                                break;
456
457                                        case "req_cpu":
458                                                $sorted[$jobid] = timeToEpoch( $req_cpu );
459                                                break;
460
461                                        case "req_mem":
462                                                $sorted[$jobid] = $req_memory;
463                                                break;
464
465                                        case "nodes":
466                                                $sorted[$jobid] = $nodes;
467                                                break;
468
469                                        case "cpus":
470                                                $sorted[$jobid] = $cpus;
471                                                break;
472
473                                        case "queued":
474                                                $sorted[$jobid] = $queued_time;
475                                                break;
476
477                                        case "start":
478                                                $sorted[$jobid] = $start_time;
479                                                break;
480
481                                        case "runningtime":
482                                                $sorted[$jobid] = $runningtime;
483                                                break;
484
485                                        default:
486                                                break;
487                                }
488                }
489        }
490
491        if( $sortorder == "asc" )
492        {
493                arsort( $sorted );
494        }
495        else if( $sortorder == "desc" )
496        {
497                asort( $sorted );
498        }
499
500        return $sorted;
501}
502
503function makeOverview() 
504{
505        global $jobs, $nodes, $heartbeat, $clustername, $tpl;
506        global $sortorder, $sortby, $filter, $sh, $hc, $m, $range;
507        global $cluster_url, $get_metric_string, $host_url, $metrics;
508        global $start, $end, $reports, $gnodes, $default_showhosts;
509        global $COLUMN_QUEUED, $COLUMN_REQUESTED_MEMORY, $COLUMN_NODES, $hostname;
510        global $cluster, $use_fqdn;
511
512        $metricname             = $m;
513
514        $tpl->assign("sortorder", $sortorder );
515        $tpl->assign("sortby", $sortby );
516
517        $sorted_jobs            = sortJobs( $jobs, $sortby, $sortorder );
518
519        $even                   = 1;
520
521        $used_jobs              = 0;
522        $used_cpus              = 0;
523        $used_nodes             = 0;
524
525        $queued_jobs            = 0;
526        $queued_nodes           = 0;
527        $queued_cpus            = 0;
528
529        $total_nodes            = 0;
530        $total_cpus             = 0;
531        $total_jobs             = 0;
532
533        $all_used_nodes         = array();
534        $total_used_nodes       = array();
535
536        $running_name_nodes     = array();
537
538        $running_nodes          = 0;
539        $running_jobs           = 0;
540        $running_cpus           = 0;
541
542        $avail_nodes            = count( $gnodes );
543        $avail_cpus             = cluster_sum("cpu_num", $metrics);
544
545        $view_cpus              = 0;
546        $view_jobs              = 0;
547        $view_nodes             = 0;
548
549        $all_nodes              = 0;
550        $all_jobs               = 0;
551        $all_cpus               = 0;
552
553        $view_name_nodes        = array();
554
555        // Is the "requested memory" column enabled in the config
556        //
557        if( $COLUMN_REQUESTED_MEMORY ) 
558        {
559                $tpl->newBlock( "column_header_req_mem" );
560        }
561
562        // Is the "nodes hostnames" column enabled in the config
563        //
564        if( $COLUMN_NODES ) 
565        {
566                $tpl->newBlock( "column_header_nodes" );
567        }
568
569        // Is the "queued time" column enabled in the config
570        //
571        if( $COLUMN_QUEUED ) 
572        {
573                $tpl->newBlock( "column_header_queued" );
574        }
575
576        $last_displayed_job     = null;
577
578        $rjqj_host              = null;
579
580        $na_nodes               = 0;
581        $na_cpus                = 0;
582
583        foreach( $metrics as $bhost => $bmetric )
584        {
585                foreach( $bmetric as $mname => $mval )
586                {
587                        if( ( $mname == 'MONARCH-RJ' ) || ($mname == 'MONARCH-QJ') )
588                        {
589                                $rjqj_host      = $bhost;
590                        }
591                }
592        }
593
594        foreach( $gnodes as $ghost => $gnode )
595        {
596                if( $gnode->isDown() || $gnode->isOffline() )
597                {
598                        $na_nodes       += 1;
599                        $na_cpus        += $metrics[$ghost]['cpu_num']['VAL'];
600                }
601        }
602
603        // Running / queued amount jobs graph
604        //
605        if( $rjqj_host != null )
606        {
607
608                $rjqj_str  = "<A HREF=\"./graph.php?z=large&c=$clustername&g=job_report&r=$range&st=$cluster[LOCALTIME]\">";
609                $rjqj_str .= "<IMG BORDER=0 SRC=\"./graph.php?z=small&c=$clustername&g=job_report&r=$range&st=$cluster[LOCALTIME]\">";
610                $rjqj_str .= "</A>";
611
612                $tpl->gotoBlock( "_ROOT" );
613
614                $tpl->assign( "rjqj_graph", $rjqj_str );
615        }
616
617        foreach( $sorted_jobs as $jobid => $sortdec ) 
618        {
619                $report_time    = $jobs[$jobid][reported];
620
621                if( $jobs[$jobid][status] == 'R' )
622                {
623                        $nodes = count( $jobs[$jobid][nodes] );
624                }
625                else if( $jobs[$jobid][status] == 'Q' )
626                {
627                        $nodes = $jobs[$jobid][nodes];
628                }
629
630                $ppn            = (int) $jobs[$jobid][ppn] ? $jobs[$jobid][ppn] : 1;
631                $cpus           = $nodes * $ppn;
632
633                if( $report_time == $heartbeat ) 
634                {
635                        $display_job    = 1;
636
637                        if( $jobs[$jobid][status] == 'R' ) 
638                        {
639                                foreach( $jobs[$jobid][nodes] as $tempnode ) 
640                                {
641                                        $all_used_nodes[] = $tempnode;
642                                }
643                        }
644
645                        $used_cpus += $cpus;
646
647                        if( $jobs[$jobid][status] == 'R' ) 
648                        {
649                                $running_cpus   += $cpus;
650
651                                $running_jobs++;
652
653                                $found_node_job = 0;
654
655                                foreach( $jobs[$jobid][nodes] as $tempnode ) 
656                                {
657                                        $running_name_nodes[] = $tempnode;
658
659                                        if( isset( $hostname ) && $hostname != '' ) 
660                                        {
661                                                //$filter[host] = $hostname;
662
663                                                $domain_len     = 0 - strlen( $jobs[$jobid][domain] );
664                                                $hostnode       = $tempnode;
665
666                                                if( $use_fqdn == 1)
667                                                {
668                                                        if( substr( $hostnode, $domain_len ) != $jobs[$jobid][domain] ) 
669                                                        {
670                                                                $hostnode = $hostnode. '.'. $jobs[$jobid][domain];
671                                                        }
672                                                }
673
674                                                if( $hostname == $hostnode ) 
675                                                {
676                                                        $found_node_job = 1;
677                                                        $display_job = 1;
678                                                } 
679                                                else if( !$found_node_job ) 
680                                                {
681                                                        $display_job = 0;
682                                                }
683                                        }
684                                }
685                        }
686
687                        if( $jobs[$jobid][status] == 'Q' ) 
688                        {
689                                if( isset( $hostname ) && $hostname != '' )
690                                {
691                                        $display_job = 0;
692                                }
693
694                                $queued_cpus    += $cpus;
695                                $queued_nodes   += $nodes;
696
697                                $queued_jobs++;
698                        }
699
700                        foreach( $filter as $filtername=>$filtervalue ) 
701                        {
702                                if( $filtername == 'id' && $jobid != $filtervalue )
703                                {
704                                        $display_job = 0;
705                                }
706                                else if( $filtername == 'state' && $jobs[$jobid][status] != $filtervalue )
707                                {
708                                        $display_job = 0;
709                                }
710                                else if( $filtername == 'queue' && $jobs[$jobid][queue] != $filtervalue )
711                                {
712                                        $display_job = 0;
713                                }
714                                else if( $filtername == 'user' && $jobs[$jobid][owner] != $filtervalue )
715                                {
716                                        $display_job = 0;
717                                }
718                        }
719
720                        if( $display_job ) 
721                        {
722                                $tpl->newBlock( "node" );
723                                $tpl->assign( "clustername", $clustername );
724                                $tpl->assign( "id", $jobid );
725
726                                $last_displayed_job     = $jobid;
727
728                                $tpl->assign( "state", $jobs[$jobid][status] );
729
730                                $fullstate              = '';
731
732                                if( $jobs[$jobid][status] == 'R' ) 
733                                {
734                                        $fullstate      = "Running";
735                                } 
736                                else if( $jobs[$jobid][status] == 'Q' ) 
737                                {
738                                        $fullstate      = "Queued";
739                                }
740
741                                $tpl->assign( "fullstate", $fullstate );
742                               
743                                $tpl->assign( "user", $jobs[$jobid][owner] );
744                                $tpl->assign( "queue", $jobs[$jobid][queue] );
745
746                                $fulljobname            = $jobs[$jobid][name];
747                                $shortjobname           = '';
748
749                                $tpl->assign( "fulljobname", $fulljobname );
750
751                                $fulljobname_fields     = explode( ' ', $fulljobname );
752
753                                $capjobname             = 0;
754
755                                if( strlen( $fulljobname_fields[0] ) > 10 )
756                                {
757                                        $capjobname     = 1;
758                                }
759
760                                if( $capjobname ) 
761                                {
762                                        $tpl->newBlock( "jobname_hint_start" );
763                                        $tpl->gotoBlock( "node" );
764
765                                        $shortjobname   = substr( $fulljobname, 0, 10 ) . '..';
766                                } 
767                                else 
768                                {
769                                        $shortjobname   = $fulljobname;
770                                }
771                               
772                                $tpl->assign( "name", $shortjobname );
773
774                                if( $capjobname ) 
775                                {
776                                        $tpl->newBlock( "jobname_hint_end" );
777                                        $tpl->gotoBlock( "node" );
778                                }
779
780                                $domain                 = $jobs[$jobid][domain];
781
782                                $tpl->assign( "req_cpu", makeTime( timeToEpoch( $jobs[$jobid][requested_time] ) ) );
783
784                                if( $COLUMN_REQUESTED_MEMORY ) 
785                                {
786                                        $tpl->newBlock( "column_req_mem" );
787                                        $tpl->assign( "req_memory", $jobs[$jobid][requested_memory] );
788                                        $tpl->gotoBlock( "node" );
789                                }
790
791
792                                if( $COLUMN_QUEUED ) 
793                                {
794                                        $tpl->newBlock( "column_queued" );
795                                        $tpl->assign( "queued", makeDate( $jobs[$jobid][queued_timestamp] ) );
796                                        $tpl->gotoBlock( "node" );
797                                }
798                                if( $COLUMN_NODES ) 
799                                {
800                                        $tpl->newBlock( "column_nodes" );
801                                        $tpl->gotoBlock( "node" );
802                                }
803
804                                $ppn                    = (int) $jobs[$jobid][ppn] ? $jobs[$jobid][ppn] : 1;
805                                $cpus                   = $nodes * $ppn;
806
807                                $tpl->assign( "nodes", $nodes );
808                                $tpl->assign( "cpus", $cpus );
809
810                                $start_time             = (int) $jobs[$jobid][start_timestamp];
811                                $job_start              = $start_time;
812
813                                $view_cpus              += $cpus;
814
815                                $view_jobs++;
816
817                                if( $jobs[$jobid][status] == 'R' ) 
818                                {
819                                        foreach( $jobs[$jobid][nodes] as $tempnode )
820                                        {
821                                                $view_name_nodes[]      = $tempnode;
822                                        }
823
824                                        if( $COLUMN_NODES ) 
825                                        {
826                                                $tpl->gotoBlock( "column_nodes" );
827
828                                                $mynodehosts            = array();
829
830                                                foreach( $jobs[$jobid][nodes] as $mynode ) 
831                                                {
832                                                        if( $use_fqdn == 1)
833                                                        {
834                                                                $mynode = $mynode.".".$jobs[$jobid][domain];
835                                                        }
836                                                        $myhost_href    = "./?c=".$clustername."&h=".$mynode;
837                                                        $mynodehosts[]  = "<A HREF=\"".$myhost_href."\">".$mynode."</A>";
838                                                }
839
840                                                $nodes_hostnames        = implode( " ", $mynodehosts );
841
842                                                $tpl->assign( "nodes_hostnames", $nodes_hostnames );
843                                                $tpl->gotoBlock( "node" );
844                                        }
845                                } 
846                                else if( $jobs[$jobid][status] == 'Q' ) 
847                                {
848                                        $view_nodes     += (int) $jobs[$jobid][nodes];
849                                }
850
851                                if( $even ) 
852                                {
853                                        $tpl->assign( "nodeclass", "even" );
854
855                                        $even           = 0;
856                                } 
857                                else 
858                                {
859                                        $tpl->assign( "nodeclass", "odd" );
860
861                                        $even           = 1;
862                                }
863
864                                if( $start_time ) 
865                                {
866                                        $runningtime            = makeTime( $report_time - $start_time );
867                                        //$job_runningtime      = $report_time - $start_time;
868                                        $job_runningtime        = $heartbeat - $start_time;
869
870                                        $tpl->assign( "started", makeDate( $start_time ) );
871                                        $tpl->assign( "runningtime", $runningtime );
872                                }
873                        }
874                }
875        }
876
877        $all_used_nodes         = array_unique( $all_used_nodes );
878        $view_name_nodes        = array_unique( $view_name_nodes );
879        $running_name_nodes     = array_unique( $running_name_nodes );
880
881        $used_nodes             = count( $all_used_nodes );
882        $view_nodes             += count( $view_name_nodes );
883        $running_nodes          += count( $running_name_nodes );
884
885        $total_nodes            = $queued_nodes + $running_nodes;
886        $total_cpus             = $queued_cpus + $running_cpus;
887        $total_jobs             = $queued_jobs + $running_jobs;
888
889        $free_nodes             = $avail_nodes - $running_nodes - $na_nodes;
890        $free_nodes             = ( $free_nodes >= 0 ) ? $free_nodes : 0;
891        $free_cpus              = $avail_cpus - $running_cpus - $na_cpus;
892        $free_cpus              = ( $free_cpus >= 0 ) ? $free_cpus : 0;
893
894        $tpl->assignGlobal( "avail_nodes", $avail_nodes );
895        $tpl->assignGlobal( "avail_cpus", $avail_cpus );
896
897        $tpl->assignGlobal( "queued_nodes", $queued_nodes );
898        $tpl->assignGlobal( "queued_jobs", $queued_jobs );
899        $tpl->assignGlobal( "queued_cpus", $queued_cpus );
900
901        // Only display "Unavailable" in count overview there are any
902        //
903        if( $na_nodes > 0 )
904        {
905                $tpl->newBlock( "na_nodes" );
906
907                $tpl->assignGlobal( "na_nodes", $na_nodes );
908                $tpl->assignGlobal( "na_cpus", $na_cpus );
909
910                $tpl->gotoBlock( "_ROOT" );
911        }
912
913        $tpl->assignGlobal( "total_nodes", $total_nodes );
914        $tpl->assignGlobal( "total_jobs", $total_jobs );
915        $tpl->assignGlobal( "total_cpus", $total_cpus );
916
917        $tpl->assignGlobal( "running_nodes", $running_nodes );
918        $tpl->assignGlobal( "running_jobs", $running_jobs );
919        $tpl->assignGlobal( "running_cpus", $running_cpus );
920
921        $tpl->assignGlobal( "used_nodes", $used_nodes );
922        $tpl->assignGlobal( "used_jobs", $used_jobs );
923        $tpl->assignGlobal( "used_cpus", $used_cpus );
924
925        $tpl->assignGlobal( "free_nodes", $free_nodes );
926        $tpl->assignGlobal( "free_cpus", $free_cpus );
927
928        $tpl->assignGlobal( "view_nodes", $view_nodes );
929        $tpl->assignGlobal( "view_jobs", $view_jobs );
930        $tpl->assignGlobal( "view_cpus", $view_cpus );
931
932        $tpl->assignGlobal( "report_time", makeDate( $heartbeat) );
933
934        if( intval($view_jobs) == 1 and $start_time )
935        {
936                if( $last_displayed_job != null )
937                {
938                        $filter[id] = $last_displayed_job;
939                }
940        }
941
942        //print_r( $metrics );
943
944        global $longtitle, $title;
945
946        $longtitle = "Batch Report :: Powered by Job Monarch!";
947        $title = "Batch Report";
948
949        makeHeader( 'overview', $title, $longtitle );
950
951        setupFilterSettings();
952
953        if( intval($view_jobs) == 1 and $start_time ) 
954        {
955                $tpl->newBlock( "showhosts" );
956
957                # Present a width list
958                $cols_menu      = "<SELECT NAME=\"hc\" OnChange=\"toga_form.submit();\">\n";
959
960                $hostcols       = ($hc) ? $hc : 4;
961
962                foreach( range( 1, 25 ) as $cols ) 
963                {
964                        $cols_menu      .= "<OPTION VALUE=$cols ";
965
966                        if ($cols == $hostcols)
967                        {
968                                $cols_menu      .= "SELECTED";
969                        }
970                        $cols_menu      .= ">$cols\n";
971                }
972                $cols_menu      .= "</SELECT>\n";
973
974                $tpl->assign( "metric","$metricname $units" );
975                $tpl->assign( "id", $filter[id] );
976
977                # Host columns menu defined in header.php
978                $tpl->assign( "cols_menu", $cols_menu );
979
980                $showhosts      = isset($sh) ? $sh : $default_showhosts;
981
982                $tpl->assign( "checked$showhosts", "checked" );
983
984                if( $showhosts ) 
985                {
986                        if( !isset( $start ) ) 
987                        {
988                                $start  ="jobstart";
989                        }
990                        if( !isset( $stop ) ) 
991                        {
992                                $stop   ="now";
993                        }
994
995                        $sorted_hosts   = array();
996                        $hosts_up       = $jobs[$filter[id]][nodes];
997
998                        //printf( "r %s\n", $job_runningtime );
999
1000                        $r              = intval($job_runningtime * 1.2);
1001
1002                        //$jobrange     = ($job_runningtime < 3600) ? -3600 : -$r ;
1003                        $jobrange       = -$r ;
1004                        //$jobstart     = $report_time - $job_runningtime;
1005                        $jobstart       = $start_time;
1006
1007                        //printf( "jr %s\n", $jobrange );
1008                        //printf( "js %s\n", $jobstart);
1009
1010                        if ( $reports[$metricname] )
1011                        {
1012                                $metricval      = "g";
1013                        }
1014                        else
1015                        {
1016                                $metricval      = "m";
1017                        }
1018                               
1019                        foreach ( $hosts_up as $host ) 
1020                        {
1021                                $domain_len             = 0 - strlen( $domain );
1022
1023                                if( $use_fqdn )
1024                                {
1025                                        if( substr( $host, $domain_len ) != $domain ) 
1026                                        {
1027                                                $host           = $host . '.' . $domain;
1028                                        }
1029                                }
1030
1031                                $cpus                   = $metrics[$host]["cpu_num"]["VAL"];
1032
1033                                if ( !$cpus )
1034                                {
1035                                        $cpus           = 1;
1036                                }
1037
1038                                $load_one               = $metrics[$host]["load_one"][VAL];
1039                                $load                   = ((float) $load_one) / $cpus;
1040                                $host_load[$host]       = $load;
1041
1042                                $percent_hosts[load_color($load)] ++;
1043
1044                                if ($metricname=="load_one")
1045                                {
1046                                        $sorted_hosts[$host]    = $load;
1047                                }
1048                                else
1049                                {
1050                                        $sorted_hosts[$host]    = $metrics[$host][$metricname][VAL];
1051                                }
1052                        }
1053
1054                        switch ( $sort ) 
1055                        {
1056                                case "descending":
1057                                        arsort( $sorted_hosts );
1058                                        break;
1059
1060                                case "by hostname":
1061                                        ksort( $sorted_hosts );
1062                                        break;
1063
1064                                case "ascending":
1065                                        asort( $sorted_hosts );
1066                                        break;
1067
1068                                default:
1069                                        break;
1070                        }
1071
1072                        // First pass to find the max value in all graphs for this
1073                        // metric. The $start,$end variables comes from get_context.php,
1074                        // included in index.php.
1075                        //
1076                        list($min, $max) = find_limits($sorted_hosts, $metricname);
1077
1078                        // Second pass to output the graphs or metrics.
1079                        $i = 1;
1080
1081                        foreach ( $sorted_hosts as $host=>$value  ) 
1082                        {
1083                                $tpl->newBlock( "sorted_list" );
1084
1085                                $host_url       = rawurlencode( $host );
1086                                $cluster_url    = rawurlencode( $clustername );
1087
1088                                $textval        = "";
1089
1090                                $val            = $metrics[$host][$metricname];
1091                                $class          = "metric";
1092                                $host_link      = "\"../../?c=$cluster_url&h=$host_url&r=job&jr=$jobrange&js=$jobstart\"";
1093
1094                                if ( $val["TYPE"] == "timestamp" || $always_timestamp[$metricname] )
1095                                {
1096                                        $textval        = date( "r", $val["VAL"] );
1097                                }
1098                                elseif ( $val["TYPE"] == "string" || $val["SLOPE"] == "zero" || $always_constant[$metricname] || ($max_graphs > 0 and $i > $max_graphs ))
1099                                {
1100                                        $textval        = $val["VAL"] . " " . $val["UNITS"];
1101                                }
1102                                else
1103                                {
1104                                        $load_color     = load_color($host_load[$host]);
1105                                        $graphargs      = ($reports[$metricname]) ? "g=$metricname&" : "m=$metricname&";
1106                                        $graphargs      .= "z=small&c=$cluster_url&h=$host_url&l=$load_color" . "&v=$val[VAL]&r=job&jr=$jobrange&js=$jobstart";
1107                                        if( $max > 0 )
1108                                        {
1109                                                $graphargs      .= "&x=$max&n=$min";
1110                                        }
1111                                }
1112                                if ($textval)
1113                                {
1114                                        $cell   = "<td class=$class>".  "<b><a href=$host_link>$host</a></b><br>".  "<i>$metricname:</i> <b>$textval</b></td>";
1115                                } else {
1116                                        $cell   = "<td><a href=$host_link>" . "<img src=\"../../graph.php?$graphargs\" " . "alt=\"$host\" border=0></a></td>";
1117                                }
1118
1119                                $tpl->assign( "metric_image", $cell );
1120
1121                                if(! ($i++ % $hostcols) )
1122                                {
1123                                         $tpl->assign( "br", "</tr><tr>" );
1124                                }
1125                        }
1126                }
1127        }
1128}
1129?>
Note: See TracBrowser for help on using the repository browser.