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

Last change on this file since 512 was 512, checked in by bastiaans, 16 years ago

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

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