source: branches/0.4/web/addons/job_monarch/overview.php @ 710

Last change on this file since 710 was 710, checked in by ramonb, 9 years ago
  • rollback old broken change to filter names
  • Property svn:keywords set to Id
File size: 24.8 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 710 2013-03-21 19:45:17Z ramonb $
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( $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)."&j_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( "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        += isset( $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        $empty_percentage       = $empty_cpus;
275
276        $qcolors                = array();
277        $color                  = randomColor( $qcolors );
278        $qcolors[]              = $color;
279        $pie_args               .= "&free=$empty_percentage,$color";
280
281        if( isset( $piefilter ) )
282        {
283                $filterpie = array();
284        }
285
286        foreach( $nodes as $node )
287        {
288                $node_jobs      = $node->getJobs();
289                $nr_node_jobs   = count( $node_jobs );
290                $myhost         = $node->getHostname();
291                $node_cpus      = $metrics[$myhost]["cpu_num"]['VAL'];
292
293                foreach( $node_jobs as $myjob )
294                {
295                        $job_cpu                = isset( $jobs[$myjob]['ppn'] ) ? $jobs[$myjob]['ppn'] : 1;
296
297                        // Determine the weight of this job
298                        // - what percentage of the cpus is in use by this job
299                        //
300                        //$job_weight[$myjob]   = ( $job_cpu / $nr_cpus );
301                        $job_weight[$myjob]     = $job_cpu;
302
303                        if( isset( $piefilter ) ) {
304
305                                $countjob = 1;
306
307                                if( $piefilter == 'id' )
308                                {
309                                        if( $myjob != $filter[$piefilter] )
310                                        {
311                                                $countjob = 0;
312                                        }
313                                }
314                                else if( $piefilter == 'user' )
315                                {
316                                        if( $jobs[$myjob]['owner'] != $filter[$piefilter] )
317                                        {
318                                                $countjob = 0;
319                                        }
320                                }
321                                else
322                                {
323                                        if( $jobs[$myjob][$piefilter] != $filter[$piefilter] )
324                                        {
325                                                $countjob = 0;
326                                        }
327                                }
328
329                                if( $countjob )
330                                {
331
332                                        if( !isset( $filterpie[$filter[$piefilter]] ) )
333                                        {
334                                                $filterpie[$filter[$piefilter]] = $job_weight[$myjob];
335                                        }
336                                        else
337                                        {
338
339                                                $filterpie[$filter[$piefilter]] = $filterpie[$filter[$piefilter]] + $job_weight[$myjob];
340                                        }
341                                }
342                                else
343                                {
344                                        if( !isset( $filterpie["other"] ) )
345                                        {
346                                                $filterpie["other"] = $job_weight[$myjob];
347                                        }
348                                        else
349                                        {
350                                                $filterpie["other"] = $filterpie["other"] + $job_weight[$myjob];
351                                        }
352
353                                }
354                               
355                        }
356                        else
357                        {
358
359                                $qname          = $jobs[$myjob]['queue'];
360
361                                if( !isset( $queues[$qname] ) )
362                                {
363                                        $queues[$qname] = $job_weight[$myjob];
364                                }
365                                else
366                                {
367                                        $queues[$qname] = $queues[$qname] + $job_weight[$myjob];
368                                }
369                        }
370                }
371        }
372
373        if( isset( $piefilter ) )
374        {
375                $graphvals = $filterpie;
376        }
377        else
378        {
379                $graphvals = $queues;
380        }
381
382        //$percentage   = 0;
383        //$slice_count  = 0;
384
385        // Find rounding errors: total has to be 100
386        //
387        //foreach( $graphvals as $name => $totalweight)
388        //{
389        //      $percentage     = $percentage + $totalweight;
390        //      $slice_count    = $slice_count + 1;
391        //}
392
393        //$round_offset = ( 100 - $percentage ) / $slice_count;
394
395        foreach( $graphvals as $name => $totalweight) 
396        {
397                //$percentage   = ( $totalweight * 100 ) + $round_offset;
398                $percentage     = $totalweight;
399               
400                $color          = randomColor( $qcolors );
401                $qcolors[]      = $color;
402                $pie_args       .= "&$name=$percentage,$color";
403        }
404        $pie = "../../pie.php?$pie_args";
405
406        return $pie;
407}
408
409
410function sortJobs( $jobs, $sortby, $sortorder ) 
411{
412        $sorted = array();
413
414        $cmp    = create_function( '$a, $b', 
415                "global \$sortby, \$sortorder;".
416
417                "if( \$a == \$b ) return 0;".
418
419                "if (\$sortorder==\"desc\")".
420                        "return ( \$a < \$b ) ? 1 : -1;".
421                "else if (\$sortorder==\"asc\")".
422                        "return ( \$a > \$b ) ? 1 : -1;" );
423
424        if( isset( $jobs ) && count( $jobs ) > 0 ) 
425        {
426                foreach( $jobs as $jobid => $jobattrs ) 
427                {
428                                $state          = $jobattrs['status'];
429                                $user           = $jobattrs['owner'];
430                                $queue          = $jobattrs['queue'];
431                                $name           = $jobattrs['name'];
432                                $req_cpu        = $jobattrs['requested_time'];
433                                $req_memory     = $jobattrs['requested_memory'];
434
435                                if( $state == 'R' )
436                                {
437                                        $nodes = count( $jobattrs['nodes'] );
438                                }
439                                else
440                                {
441                                        $nodes = $jobattrs['nodes'];
442                                }
443
444                                $ppn            = (int) $jobattrs['ppn'] ? $jobattrs['ppn'] : 1;
445                                $cpus           = $nodes * $ppn;
446                                $queued_time    = (int) $jobattrs['queued_timestamp'];
447                                $start_time     = (int) $jobattrs['start_timestamp'];
448                                $runningtime    = $report_time - $start_time;
449
450                                switch( $sortby ) 
451                                {
452                                        case "id":
453                                                $sorted[$jobid] = $jobid;
454                                                break;
455
456                                        case "state":
457                                                $sorted[$jobid] = $state;
458                                                break;
459
460                                        case "user":
461                                                $sorted[$jobid] = $user;
462                                                break;
463
464                                        case "queue":
465                                                $sorted[$jobid] = $queue;
466                                                break;
467
468                                        case "name":
469                                                $sorted[$jobid] = $name;
470                                                break;
471
472                                        case "req_cpu":
473                                                $sorted[$jobid] = timeToEpoch( $req_cpu );
474                                                break;
475
476                                        case "req_mem":
477                                                $sorted[$jobid] = $req_memory;
478                                                break;
479
480                                        case "nodes":
481                                                $sorted[$jobid] = $nodes;
482                                                break;
483
484                                        case "cpus":
485                                                $sorted[$jobid] = $cpus;
486                                                break;
487
488                                        case "queued":
489                                                $sorted[$jobid] = $queued_time;
490                                                break;
491
492                                        case "start":
493                                                $sorted[$jobid] = $start_time;
494                                                break;
495
496                                        case "runningtime":
497                                                $sorted[$jobid] = $runningtime;
498                                                break;
499
500                                        default:
501                                                break;
502                                }
503                }
504        }
505
506        if( $sortorder == "asc" )
507        {
508                arsort( $sorted );
509        }
510        else if( $sortorder == "desc" )
511        {
512                asort( $sorted );
513        }
514
515        return $sorted;
516}
517
518function makeOverview() 
519{
520        global $jobs, $nodes, $heartbeat, $clustername, $tpl;
521        global $sortorder, $sortby, $filter, $sh, $hc, $m, $range;
522        global $cluster_url, $get_metric_string, $host_url, $metrics;
523        global $start, $end, $reports, $gnodes, $default_showhosts;
524        global $COLUMN_QUEUED, $COLUMN_REQUESTED_MEMORY, $COLUMN_NODES, $hostname;
525        global $cluster, $use_fqdn;
526
527        $metricname             = $m;
528
529        $tpl->assign("sortorder", $sortorder );
530        $tpl->assign("sortby", $sortby );
531
532        $sorted_jobs            = sortJobs( $jobs, $sortby, $sortorder );
533
534        $even                   = 1;
535
536        $used_jobs              = 0;
537        $used_cpus              = 0;
538        $used_nodes             = 0;
539
540        $queued_jobs            = 0;
541        $queued_nodes           = 0;
542        $queued_cpus            = 0;
543
544        $total_nodes            = 0;
545        $total_cpus             = 0;
546        $total_jobs             = 0;
547
548        $all_used_nodes         = array();
549        $total_used_nodes       = array();
550
551        $running_name_nodes     = array();
552
553        $running_nodes          = 0;
554        $running_jobs           = 0;
555        $running_cpus           = 0;
556
557        $avail_nodes            = count( $gnodes );
558        $avail_cpus             = cluster_sum("cpu_num", $metrics);
559
560        $view_cpus              = 0;
561        $view_jobs              = 0;
562        $view_nodes             = 0;
563
564        $all_nodes              = 0;
565        $all_jobs               = 0;
566        $all_cpus               = 0;
567
568        $view_name_nodes        = array();
569
570        // Is the "requested memory" column enabled in the config
571        //
572        if( $COLUMN_REQUESTED_MEMORY ) 
573        {
574                $tpl->newBlock( "column_header_req_mem" );
575        }
576
577        // Is the "nodes hostnames" column enabled in the config
578        //
579        if( $COLUMN_NODES ) 
580        {
581                $tpl->newBlock( "column_header_nodes" );
582        }
583
584        // Is the "queued time" column enabled in the config
585        //
586        if( $COLUMN_QUEUED ) 
587        {
588                $tpl->newBlock( "column_header_queued" );
589        }
590
591        $last_displayed_job     = null;
592
593        $rjqj_host              = null;
594
595        $na_nodes               = 0;
596        $na_cpus                = 0;
597
598        foreach( $metrics as $bhost => $bmetric )
599        {
600                foreach( $bmetric as $mname => $mval )
601                {
602                        if( ( $mname == 'MONARCH-RJ' ) || ($mname == 'MONARCH-QJ') )
603                        {
604                                $rjqj_host      = $bhost;
605                        }
606                }
607        }
608
609        foreach( $gnodes as $ghost => $gnode )
610        {
611                if( $gnode->isDown() || $gnode->isOffline() )
612                {
613                        $na_nodes       += 1;
614                        $na_cpus        += $metrics[$ghost]['cpu_num']['VAL'];
615                }
616        }
617
618        // Running / queued amount jobs graph
619        //
620        if( $rjqj_host != null )
621        {
622
623                $rjqj_str  = "<A HREF=\"./graph.php?z=large&c=$clustername&g=job_report&r=$range&st=$cluster[LOCALTIME]\">";
624                $rjqj_str .= "<IMG BORDER=0 SRC=\"./graph.php?z=small&c=$clustername&g=job_report&r=$range&st=$cluster[LOCALTIME]\">";
625                $rjqj_str .= "</A>";
626
627                $tpl->gotoBlock( "_ROOT" );
628
629                $tpl->assign( "rjqj_graph", $rjqj_str );
630        }
631
632        foreach( $sorted_jobs as $jobid => $sortdec ) 
633        {
634                $report_time    = $jobs[$jobid]['reported'];
635
636                if( $jobs[$jobid]['status'] == 'R' )
637                {
638                        $nodes = count( $jobs[$jobid]['nodes'] );
639                }
640                else if( $jobs[$jobid]['status'] == 'Q' )
641                {
642                        $nodes = $jobs[$jobid]['nodes'];
643                }
644
645                $ppn            = isset( $jobs[$jobid]['ppn'] ) ? $jobs[$jobid]['ppn'] : 1;
646                $cpus           = $nodes * $ppn;
647
648                if( $report_time == $heartbeat ) 
649                {
650                        $display_job    = 1;
651
652                        if( $jobs[$jobid]['status'] == 'R' ) 
653                        {
654                                foreach( $jobs[$jobid]['nodes'] as $tempnode ) 
655                                {
656                                        $all_used_nodes[] = $tempnode;
657                                }
658                        }
659
660                        $used_cpus += $cpus;
661
662                        if( $jobs[$jobid]['status'] == 'R' ) 
663                        {
664                                $running_cpus   += $cpus;
665
666                                $running_jobs++;
667
668                                $found_node_job = 0;
669
670                                foreach( $jobs[$jobid]['nodes'] as $tempnode ) 
671                                {
672                                        $running_name_nodes[] = $tempnode;
673
674                                        if( isset( $hostname ) && $hostname != '' ) 
675                                        {
676                                                //$filter[host] = $hostname;
677
678                                                $domain_len     = 0 - strlen( $jobs[$jobid]['domain'] );
679                                                $hostnode       = $tempnode;
680
681                                                if( $use_fqdn == 1)
682                                                {
683                                                        if( substr( $hostnode, $domain_len ) != $jobs[$jobid]['domain'] ) 
684                                                        {
685                                                                $hostnode = $hostnode. '.'. $jobs[$jobid]['domain'];
686                                                        }
687                                                }
688
689                                                if( $hostname == $hostnode ) 
690                                                {
691                                                        $found_node_job = 1;
692                                                        $display_job = 1;
693                                                } 
694                                                else if( !$found_node_job ) 
695                                                {
696                                                        $display_job = 0;
697                                                }
698                                        }
699                                }
700                        }
701
702                        if( $jobs[$jobid]['status'] == 'Q' ) 
703                        {
704                                if( isset( $hostname ) && $hostname != '' )
705                                {
706                                        $display_job = 0;
707                                }
708
709                                $queued_cpus    += $cpus;
710                                $queued_nodes   += $nodes;
711
712                                $queued_jobs++;
713                        }
714
715                        foreach( $filter as $filtername=>$filtervalue ) 
716                        {
717                                if( $filtername == 'id' && $jobid != $filtervalue )
718                                {
719                                        $display_job = 0;
720                                }
721                                else if( $filtername == 'state' && $jobs[$jobid]['status'] != $filtervalue )
722                                {
723                                        $display_job = 0;
724                                }
725                                else if( $filtername == 'queue' && $jobs[$jobid]['queue'] != $filtervalue )
726                                {
727                                        $display_job = 0;
728                                }
729                                else if( $filtername == 'user' && $jobs[$jobid]['owner'] != $filtervalue )
730                                {
731                                        $display_job = 0;
732                                }
733                        }
734
735                        if( $display_job ) 
736                        {
737                                $tpl->newBlock( "node" );
738                                $tpl->assign( "clustername", $clustername );
739                                $tpl->assign( "id", $jobid );
740
741                                $last_displayed_job     = $jobid;
742
743                                $tpl->assign( "state", $jobs[$jobid]['status'] );
744
745                                $fullstate              = '';
746
747                                if( $jobs[$jobid]['status'] == 'R' ) 
748                                {
749                                        $fullstate      = "Running";
750                                } 
751                                else if( $jobs[$jobid]['status'] == 'Q' ) 
752                                {
753                                        $fullstate      = "Queued";
754                                }
755
756                                $tpl->assign( "fullstate", $fullstate );
757                               
758                                $tpl->assign( "user", $jobs[$jobid]['owner'] );
759                                $tpl->assign( "queue", $jobs[$jobid]['queue'] );
760
761                                $fulljobname            = $jobs[$jobid]['name'];
762                                $shortjobname           = '';
763
764                                $tpl->assign( "fulljobname", $fulljobname );
765
766                                $fulljobname_fields     = explode( ' ', $fulljobname );
767
768                                $capjobname             = 0;
769
770                                if( strlen( $fulljobname_fields[0] ) > 10 )
771                                {
772                                        $capjobname     = 1;
773                                }
774
775                                if( $capjobname ) 
776                                {
777                                        $tpl->newBlock( "jobname_hint_start" );
778                                        $tpl->gotoBlock( "node" );
779
780                                        $shortjobname   = substr( $fulljobname, 0, 10 ) . '..';
781                                } 
782                                else 
783                                {
784                                        $shortjobname   = $fulljobname;
785                                }
786                               
787                                $tpl->assign( "name", $shortjobname );
788
789                                if( $capjobname ) 
790                                {
791                                        $tpl->newBlock( "jobname_hint_end" );
792                                        $tpl->gotoBlock( "node" );
793                                }
794
795                                $domain                 = $jobs[$jobid]['domain'];
796
797                                $tpl->assign( "req_cpu", makeTime( timeToEpoch( $jobs[$jobid]['requested_time'] ) ) );
798
799                                if( $COLUMN_REQUESTED_MEMORY ) 
800                                {
801                                        $tpl->newBlock( "column_req_mem" );
802                                        $tpl->assign( "req_memory", $jobs[$jobid]['requested_memory'] );
803                                        $tpl->gotoBlock( "node" );
804                                }
805
806
807                                if( $COLUMN_QUEUED ) 
808                                {
809                                        $tpl->newBlock( "column_queued" );
810                                        $tpl->assign( "queued", makeDate( $jobs[$jobid]['queued_timestamp'] ) );
811                                        $tpl->gotoBlock( "node" );
812                                }
813                                if( $COLUMN_NODES ) 
814                                {
815                                        $tpl->newBlock( "column_nodes" );
816                                        $tpl->gotoBlock( "node" );
817                                }
818
819                                $ppn                    = isset( $jobs[$jobid]['ppn'] ) ? $jobs[$jobid]['ppn'] : 1;
820                                $cpus                   = $nodes * $ppn;
821
822                                $tpl->assign( "nodes", $nodes );
823                                $tpl->assign( "cpus", $cpus );
824
825                                $start_time             = (int) $jobs[$jobid]['start_timestamp'];
826                                $job_start              = $start_time;
827
828                                $view_cpus              += $cpus;
829
830                                $view_jobs++;
831
832                                if( $jobs[$jobid]['status'] == 'R' ) 
833                                {
834                                        foreach( $jobs[$jobid]['nodes'] as $tempnode )
835                                        {
836                                                $view_name_nodes[]      = $tempnode;
837                                        }
838
839                                        if( $COLUMN_NODES ) 
840                                        {
841                                                $tpl->gotoBlock( "column_nodes" );
842
843                                                $mynodehosts            = array();
844
845                                                foreach( $jobs[$jobid]['nodes'] as $mynode ) 
846                                                {
847                                                        if( $use_fqdn == 1)
848                                                        {
849                                                                $mynode = $mynode.".".$jobs[$jobid]['domain'];
850                                                        }
851                                                        $myhost_href    = "./?c=".$clustername."&h=".$mynode;
852                                                        $mynodehosts[]  = "<A HREF=\"".$myhost_href."\">".$mynode."</A>";
853                                                }
854
855                                                $nodes_hostnames        = implode( " ", $mynodehosts );
856
857                                                $tpl->assign( "nodes_hostnames", $nodes_hostnames );
858                                                $tpl->gotoBlock( "node" );
859                                        }
860                                } 
861                                else if( $jobs[$jobid]['status'] == 'Q' ) 
862                                {
863                                        $view_nodes     += (int) $jobs[$jobid]['nodes'];
864                                }
865
866                                if( $even ) 
867                                {
868                                        $tpl->assign( "nodeclass", "even" );
869
870                                        $even           = 0;
871                                } 
872                                else 
873                                {
874                                        $tpl->assign( "nodeclass", "odd" );
875
876                                        $even           = 1;
877                                }
878
879                                if( $start_time ) 
880                                {
881                                        $runningtime            = makeTime( $report_time - $start_time );
882                                        //$job_runningtime      = $report_time - $start_time;
883                                        $job_runningtime        = $heartbeat - $start_time;
884
885                                        $tpl->assign( "started", makeDate( $start_time ) );
886                                        $tpl->assign( "runningtime", $runningtime );
887                                }
888                        }
889                }
890        }
891
892        $all_used_nodes         = array_unique( $all_used_nodes );
893        $view_name_nodes        = array_unique( $view_name_nodes );
894        $running_name_nodes     = array_unique( $running_name_nodes );
895
896        $used_nodes             = count( $all_used_nodes );
897        $view_nodes             += count( $view_name_nodes );
898        $running_nodes          += count( $running_name_nodes );
899
900        $total_nodes            = $queued_nodes + $running_nodes;
901        $total_cpus             = $queued_cpus + $running_cpus;
902        $total_jobs             = $queued_jobs + $running_jobs;
903
904        $free_nodes             = $avail_nodes - $running_nodes - $na_nodes;
905        $free_nodes             = ( $free_nodes >= 0 ) ? $free_nodes : 0;
906        $free_cpus              = $avail_cpus - $running_cpus - $na_cpus;
907        $free_cpus              = ( $free_cpus >= 0 ) ? $free_cpus : 0;
908
909        $tpl->assignGlobal( "avail_nodes", $avail_nodes );
910        $tpl->assignGlobal( "avail_cpus", $avail_cpus );
911
912        $tpl->assignGlobal( "queued_nodes", $queued_nodes );
913        $tpl->assignGlobal( "queued_jobs", $queued_jobs );
914        $tpl->assignGlobal( "queued_cpus", $queued_cpus );
915
916        // Only display "Unavailable" in count overview there are any
917        //
918        if( $na_nodes > 0 )
919        {
920                $tpl->newBlock( "na_nodes" );
921
922                $tpl->assignGlobal( "na_nodes", $na_nodes );
923                $tpl->assignGlobal( "na_cpus", $na_cpus );
924
925                $tpl->gotoBlock( "_ROOT" );
926        }
927
928        $tpl->assignGlobal( "total_nodes", $total_nodes );
929        $tpl->assignGlobal( "total_jobs", $total_jobs );
930        $tpl->assignGlobal( "total_cpus", $total_cpus );
931
932        $tpl->assignGlobal( "running_nodes", $running_nodes );
933        $tpl->assignGlobal( "running_jobs", $running_jobs );
934        $tpl->assignGlobal( "running_cpus", $running_cpus );
935
936        $tpl->assignGlobal( "used_nodes", $used_nodes );
937        $tpl->assignGlobal( "used_jobs", $used_jobs );
938        $tpl->assignGlobal( "used_cpus", $used_cpus );
939
940        $tpl->assignGlobal( "free_nodes", $free_nodes );
941        $tpl->assignGlobal( "free_cpus", $free_cpus );
942
943        $tpl->assignGlobal( "view_nodes", $view_nodes );
944        $tpl->assignGlobal( "view_jobs", $view_jobs );
945        $tpl->assignGlobal( "view_cpus", $view_cpus );
946
947        $tpl->assignGlobal( "report_time", makeDate( $heartbeat) );
948
949        if( intval($view_jobs) == 1 and $start_time )
950        {
951                if( $last_displayed_job != null )
952                {
953                        $filter['id'] = $last_displayed_job;
954                }
955        }
956
957        //print_r( $metrics );
958
959        global $longtitle, $title;
960
961        $longtitle = "Batch Report :: Powered by Job Monarch!";
962        $title = "Batch Report";
963
964        makeHeader( 'overview', $title, $longtitle );
965
966        setupFilterSettings();
967
968        if( intval($view_jobs) == 1 and $start_time ) 
969        {
970                $tpl->newBlock( "showhosts" );
971
972                # Present a width list
973                $cols_menu      = "<SELECT NAME=\"hc\" OnChange=\"toga_form.submit();\">\n";
974
975                $hostcols       = ($hc) ? $hc : 4;
976
977                foreach( range( 1, 25 ) as $cols ) 
978                {
979                        $cols_menu      .= "<OPTION VALUE=$cols ";
980
981                        if ($cols == $hostcols)
982                        {
983                                $cols_menu      .= "SELECTED";
984                        }
985                        $cols_menu      .= ">$cols\n";
986                }
987                $cols_menu      .= "</SELECT>\n";
988
989                $tpl->assign( "metric","$metricname $units" );
990                $tpl->assign( "id", $filter['id'] );
991
992                # Host columns menu defined in header.php
993                $tpl->assign( "cols_menu", $cols_menu );
994
995                $showhosts      = isset($sh) ? $sh : $default_showhosts;
996
997                $tpl->assign( "checked$showhosts", "checked" );
998
999                if( $showhosts ) 
1000                {
1001                        if( !isset( $start ) ) 
1002                        {
1003                                $start  ="jobstart";
1004                        }
1005                        if( !isset( $stop ) ) 
1006                        {
1007                                $stop   ="now";
1008                        }
1009
1010                        $sorted_hosts   = array();
1011                        $hosts_up       = $jobs[$filter['id']]['nodes'];
1012
1013                        //printf( "r %s\n", $job_runningtime );
1014
1015                        $r              = intval($job_runningtime * 1.2);
1016
1017                        //$jobrange     = ($job_runningtime < 3600) ? -3600 : -$r ;
1018                        $jobrange       = -$r ;
1019                        //$jobstart     = $report_time - $job_runningtime;
1020                        $jobstart       = $start_time;
1021
1022                        //printf( "jr %s\n", $jobrange );
1023                        //printf( "js %s\n", $jobstart);
1024
1025                        if ( $reports[$metricname] )
1026                        {
1027                                $metricval      = "g";
1028                        }
1029                        else
1030                        {
1031                                $metricval      = "m";
1032                        }
1033                               
1034                        foreach ( $hosts_up as $host ) 
1035                        {
1036                                $domain_len             = 0 - strlen( $domain );
1037
1038                                if( $use_fqdn )
1039                                {
1040                                        if( substr( $host, $domain_len ) != $domain ) 
1041                                        {
1042                                                $host           = $host . '.' . $domain;
1043                                        }
1044                                }
1045
1046                                $cpus                   = $metrics[$host]["cpu_num"]["VAL"];
1047
1048                                if ( !$cpus )
1049                                {
1050                                        $cpus           = 1;
1051                                }
1052
1053                                $load_one               = $metrics[$host]["load_one"]['VAL'];
1054                                $load                   = ((float) $load_one) / $cpus;
1055                                $host_load[$host]       = $load;
1056
1057                                $percent_hosts[load_color($load)] ++;
1058
1059                                if ($metricname=="load_one")
1060                                {
1061                                        $sorted_hosts[$host]    = $load;
1062                                }
1063                                else
1064                                {
1065                                        $sorted_hosts[$host]    = $metrics[$host][$metricname]['VAL'];
1066                                }
1067                        }
1068
1069                        switch ( $sort ) 
1070                        {
1071                                case "descending":
1072                                        arsort( $sorted_hosts );
1073                                        break;
1074
1075                                case "by hostname":
1076                                        ksort( $sorted_hosts );
1077                                        break;
1078
1079                                case "ascending":
1080                                        asort( $sorted_hosts );
1081                                        break;
1082
1083                                default:
1084                                        break;
1085                        }
1086
1087                        // First pass to find the max value in all graphs for this
1088                        // metric. The $start,$end variables comes from get_context.php,
1089                        // included in index.php.
1090                        //
1091                        list($min, $max) = find_limits($sorted_hosts, $metricname);
1092
1093                        // Second pass to output the graphs or metrics.
1094                        $i = 1;
1095
1096                        foreach ( $sorted_hosts as $host=>$value  ) 
1097                        {
1098                                $tpl->newBlock( "sorted_list" );
1099
1100                                $host_url       = rawurlencode( $host );
1101                                $cluster_url    = rawurlencode( $clustername );
1102
1103                                $textval        = "";
1104
1105                                $val            = $metrics[$host][$metricname];
1106                                $class          = "metric";
1107                                $host_link      = "\"../../?c=$cluster_url&h=$host_url&r=job&jr=$jobrange&js=$jobstart\"";
1108
1109                                if ( $val["TYPE"] == "timestamp" || $always_timestamp[$metricname] )
1110                                {
1111                                        $textval        = date( "r", $val["VAL"] );
1112                                }
1113                                elseif ( $val["TYPE"] == "string" || $val["SLOPE"] == "zero" || $always_constant[$metricname] || ($max_graphs > 0 and $i > $max_graphs ))
1114                                {
1115                                        $textval        = $val["VAL"] . " " . $val["UNITS"];
1116                                }
1117                                else
1118                                {
1119                                        $load_color     = load_color($host_load[$host]);
1120                                        $graphargs      = ($reports[$metricname]) ? "g=$metricname&" : "m=$metricname&";
1121                                        $graphargs      .= "z=small&c=$cluster_url&h=$host_url&l=$load_color&v=".$val['VAL']."&r=job&jr=$jobrange&js=$jobstart";
1122                                        if( $max > 0 )
1123                                        {
1124                                                $graphargs      .= "&x=$max&n=$min";
1125                                        }
1126                                }
1127                                if ($textval)
1128                                {
1129                                        $cell   = "<td class=$class>".  "<b><a href=$host_link>$host</a></b><br>".  "<i>$metricname:</i> <b>$textval</b></td>";
1130                                } else {
1131                                        $cell   = "<td><a href=$host_link>" . "<img src=\"../../graph.php?$graphargs\" " . "alt=\"$host\" border=0></a></td>";
1132                                }
1133
1134                                $tpl->assign( "metric_image", $cell );
1135
1136                                if(! ($i++ % $hostcols) )
1137                                {
1138                                         $tpl->assign( "br", "</tr><tr>" );
1139                                }
1140                        }
1141                }
1142        }
1143}
1144?>
Note: See TracBrowser for help on using the repository browser.