source: branches/0.4/web/addons/job_monarch/libtoga.php @ 751

Last change on this file since 751 was 751, checked in by ramonb, 9 years ago

job_monarch/libtoga.php:

  • why call Ganglia's get_ganglia.php Gmetad() if we are already parsing ourself
  • now create $metrics ourself while TorqueXMLHandler.parseXML() runs
  • more speedup...

job_monarch/host_view.php,
job_monarch/graph.php:

  • dont need job information, so no DataGatherer?: call get_ganglia.php now for $metrics
  • Property svn:keywords set to Id
File size: 71.3 KB
Line 
1<?php
2/*
3 *
4 * This file is part of Jobmonarch
5 *
6 * Copyright (C) 2006-2013  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: libtoga.php 751 2013-03-25 20:41:14Z ramonb $
23 *
24 */
25
26
27class HTTPVariables
28{
29    var $clustername, $metricname;
30    var $restvars, $httpvars;
31
32    function HTTPVariables( $httpvars, $getvars )
33    {
34        $this->restvars        = array();
35
36        $this->clustername    = isset( $httpvars["c"] ) ? $httpvars["c"] : $getvars["c"];
37        $this->metricname    = isset( $httpvars["m"] ) ? $httpvars["m"] : $getvars["m"];
38
39        if( count( $httpvars ) > 0 )
40        {
41            foreach( $httpvars as $httpvar => $httpval )
42            {
43                if( $httpval )
44                {
45                    $this->restvars[$httpvar] = $httpval;
46                }
47            }
48        }
49
50        if( count( $getvars ) > 0 )
51        {
52            foreach( $getvars as $getvar => $getval )
53            {
54                if( $getval )
55                {
56                    $this->restvars[$getvar] = $getval;
57                }
58            }
59        }
60    }
61
62    function getClusterName()
63    {
64        return $this->clustername;
65    }
66
67    function getMetricName()
68    {
69        return $this->metricname;
70    }
71
72    function getHttpVar( $var )
73    {
74        if( isset( $this->restvars[$var] ) )
75        {
76            return $this->restvars[$var];
77        }
78        else
79        {
80            return null;
81        }
82    }
83}
84
85$CLUSTER_CONFS    = array();
86
87ini_set("memory_limit","500M");
88set_time_limit(0);
89
90// Monarch's conf
91//
92include_once "./conf.php";
93include_once "./version.php";
94
95global $GANGLIA_PATH;
96global $RRDTOOL;
97global $JOB_ARCHIVE_DIR;
98global $JOB_ARCHIVE_DBASE;
99global $skan_str;
100global $x_first, $y_first;
101global $CLUSTER_CONFS;
102
103$my_dir = getcwd();
104
105// Load Ganglia's PHP
106chdir( $GANGLIA_PATH );
107
108include_once "./eval_conf.php";
109include_once "./functions.php";
110include_once "./get_context.php";
111
112global $GLOBALS, $conf, $metrics, $version, $rrdtool_version, $context;
113
114// ganglia start
115$metrics = array();
116$version = array();
117
118$version["webfrontend"] = $GLOBALS["ganglia_version"];
119
120# Get rrdtool version
121$rrdtool_version = array();
122exec($conf['rrdtool'], $rrdtool_version);
123$rrdtool_version = explode(" ", $rrdtool_version[0]);
124$rrdtool_version = $rrdtool_version[1];
125$version["rrdtool"] = "$rrdtool_version";
126
127// ganglia end
128
129$context = 'cluster';
130
131// Back to our PHP
132chdir( $my_dir );
133
134global $SMALL_CLUSTERIMAGE_MAXWIDTH, $SMALL_CLUSTERIMAGE_NODEWIDTH, $DATA_SOURCE, $HTTP_GET_VARS, $_GET;
135$httpvars = new HTTPVariables( $HTTP_GET_VARS, $_GET );
136
137// Set cluster context so that Ganglia will
138// provide us with the correct metrics array
139//
140global $context, $clustername, $reports;
141
142global $default_metric;
143
144// Ganglia's array of host metrics
145//
146global $hosts_up;
147global $start;
148
149global $DATETIME_FORMAT;
150
151function makeDate( $time )
152{
153    global $DATETIME_FORMAT;
154    return strftime( $DATETIME_FORMAT, $time );
155}
156
157
158class TarchDbase
159{
160    var $ip, $dbase, $conn;
161
162    function TarchDbase( $ip = null, $dbase = null )
163    {
164        global $CLUSTER_CONFS, $clustername;
165        global $JOB_ARCHIVE_DBASE;
166
167        // Import cluster specific settings
168        //
169        foreach( $CLUSTER_CONFS as $confcluster => $conffile )
170        {
171            if( strtolower( trim($this->clustername) ) == strtolower(trim($confcluster)) )
172            {
173                include_once $conffile;
174            }
175        }
176
177        $db_fields = explode( '/', $JOB_ARCHIVE_DBASE );
178
179        $this->ip    = $db_fields[0];
180        $this->dbase    = $db_fields[1];
181        $this->conn    = null;
182    }
183
184    function connect()
185    {
186        if( $this->ip == null )
187            $this->conn = pg_connect( "dbname=".$this->dbase );
188        else
189            $this->conn = pg_connect( "host=".$this->ip." dbname=".$this->dbase );
190    }
191
192    function searchDbase( $id = null, $queue = null, $owner = null, $name = null, $start_from_time = null, $start_to_time = null, $end_from_time = null, $end_to_time = null )
193    {
194        global $SEARCH_RESULT_LIMIT;
195
196        if( $id )
197        {
198            $select_query = "SELECT job_id FROM jobs WHERE job_id = '$id' AND job_status = 'F'";
199            $this->resultcount = 1;
200        }
201        else
202        {
203            $query_args = array();
204           
205            if( $queue )
206            {
207                $query_args[] = "job_queue ='$queue'";
208            }
209            if( $owner )
210            {
211                $query_args[] = "job_owner ='$owner'";
212            }
213            if( $name )
214            {
215                $query_args[] = "job_name = '$name'";
216            }
217            if( $start_from_time )
218            {
219                $query_args[] = "job_start_timestamp >= $start_from_time";
220            }
221            if( $start_to_time )
222            {
223                $query_args[] = "job_start_timestamp <= $start_to_time";
224            }
225            if( $end_from_time )
226            {
227                $query_args[] = "job_stop_timestamp >= $end_from_time";
228            }
229            if( $end_to_time )
230            {
231                $query_args[] = "job_stop_timestamp <= $end_to_time";
232            }
233
234            $query = "FROM jobs WHERE job_status = 'F' AND ";
235            $extra_query_args = '';
236
237            foreach( $query_args as $myquery )
238            {
239                if( $extra_query_args == '' )
240                {
241                    $extra_query_args = $myquery;
242                }
243                else
244                {
245                    $extra_query_args .= " AND ".$myquery;
246                }
247            }
248            $query .= $extra_query_args;
249
250            $count_result_idname = "COUNT(job_id)";
251            $select_result_idname = "job_id";
252
253            $count_query = "SELECT " . $count_result_idname . " " . $query;
254
255            $count_result = $this->queryDbase( $count_query );
256            $this->resultcount = (int) $count_result[0]['count'];
257
258            $select_query = "SELECT " . $select_result_idname . " " . $query . " ORDER BY job_id DESC LIMIT " . $SEARCH_RESULT_LIMIT;
259        }
260
261        $ids = $this->queryDbase( $select_query );
262
263        $ret = array();
264
265        foreach( $ids as $crow)
266        {
267            $ret[] = $crow['job_id'];
268        }
269
270        return $ret;
271    }
272
273    function getNodesForJob( $jobid )
274    {
275        $result = $this->queryDbase( "SELECT node_id FROM job_nodes WHERE job_id = '$jobid'" );
276
277        $nodes = array();
278
279        foreach( $result as $result_row ) 
280        {
281            $nodes[] = $this->getNodeArray( $result_row['node_id'] );
282        }
283
284        return $nodes;
285    }
286
287    function getJobsForNode( $nodeid )
288    {
289        $result = $this->queryDbase( "SELECT job_id FROM job_nodes WHERE node_id = '$nodeid'" );
290
291        $jobs = array();
292
293        foreach( $result as $result_row )
294        {
295            $jobs[] = $this->getJobArray( $result_row['job_id'] );
296        }
297        return $jobs;
298    }
299
300    function getJobArray( $id )
301    {
302        $result = $this->queryDbase( "SELECT * FROM jobs WHERE job_id = '$id'" );
303
304        return ( $this->makeArray( $result[0] ) );
305    }
306
307    function getNodeArray( $id )
308    {
309        $result = $this->queryDbase( "SELECT * FROM nodes WHERE node_id = '$id'" );
310
311        return ( $this->makeArray( $result[0] ) );
312    }
313
314    function makeArray( $result_row )
315    {
316        $myar = array();
317
318        foreach( $result_row as $mykey => $myval )
319        {
320            $map_key = explode( '_', $mykey );
321
322            $rmap_key = array_reverse( $map_key );
323            array_pop( $rmap_key );
324            $map_key = array_reverse( $rmap_key );
325           
326            $newkey = implode( '_', $map_key );
327           
328            $myar[$newkey] = $result_row[$mykey];
329        }
330
331        return $myar;
332    }
333
334    function queryDbase( $query )
335    {
336        $result_rows = array();
337   
338        if( !$this->conn )
339        {
340            $this->connect();
341        }
342
343        $result = pg_query( $this->conn, $query );
344
345        while ($row = pg_fetch_assoc($result))
346        {
347            $result_rows[] = $row;
348        }
349
350        return $result_rows;
351    }
352}
353
354class TarchRrdGraph
355{
356    var $rrdbin, $rrdvalues, $clustername, $hostname, $tempdir, $tarchdir, $metrics;
357
358    function TarchRrdGraph( $clustername, $hostname )
359    {
360        global $conf;
361        global $JOB_ARCHIVE_DIR;
362
363        $this->rrdbin        = $conf['rrdtool'];
364        $this->rrdvalues    = array();
365        $this->tarchdir        = $JOB_ARCHIVE_DIR;
366        $this->clustername    = $clustername;
367        $this->hostname        = $hostname;
368    }
369
370    function doCmd( $command )
371    {
372        $pipe = popen( $command . ' 2>&1', 'r' );
373
374        if (!$pipe)
375        {
376            print "pipe failed.";
377            return "";
378        }
379
380        $output = '';
381
382        while(!feof($pipe))
383        {
384            $output .= fread($pipe, 1024);
385        }
386
387        pclose($pipe);
388
389        $output = explode( "\n", $output );
390
391        return $output;
392    }
393
394    function dirList( $dir )
395    {
396        $dirlist = array();
397
398        if ($handle = opendir( $dir ))
399        {
400            while (false !== ($file = readdir($handle)))
401            {
402                if ($file != "." && $file != "..")
403                {
404                    $dirlist[] = $file;
405                }
406            }
407            closedir($handle);
408        }
409
410        return $dirlist;
411    }
412
413    function getTimePeriods( $start, $end )
414    {
415        $times = array();
416        $dirlist = $this->dirList( $this->tarchdir . '/' . $this->clustername . '/' . $this->hostname );
417
418        $first = 0;
419        $last = 9999999999999;
420
421        foreach( $dirlist as $dir )
422        {
423            if( $dir > $first and $dir <= $start )
424            {
425                $first = $dir;
426            }
427            if( $dir < $last and $dir >= $end )
428            {
429                $last = $dir;
430            }
431        }
432
433        foreach( $dirlist as $dir )
434        {
435            if( $dir >= $first and $dir <= $last and !array_key_exists( $dir, $times ) )
436            {
437                $times[] = $dir;
438            }
439        }
440
441        sort( $times );
442
443        return $times;
444    }
445
446    function getRrdDirs( $start, $stop )
447    {
448        $timess = $this->getTimePeriods( $start, $stop );
449
450        $rrd_files = array();
451
452        foreach( $timess as $time )
453        {
454            $rrd_files[] = $this->tarchdir . '/' . $this->clustername . '/' . $this->hostname. '/'.$time;
455        }
456
457        return $rrd_files;
458    }
459
460    function getRrdFiles( $metric, $start, $stop )
461    {
462        $times = $this->getTimePeriods( $start, $stop );
463
464        $rrd_files = array();
465
466        foreach( $times as $time )
467        {
468            $rrd_files[] = $this->tarchdir . '/' . $this->clustername . '/' . $this->hostname . '/' .$time. '/' . $metric. '.rrd';
469        }
470
471        return $rrd_files;
472    }
473}
474
475class DataSource
476{
477    var $data, $ip, $port;
478
479    function DataSource()
480    {
481        global $DATA_SOURCE, $clustername;
482
483        $ds_fields     = explode( ':', $DATA_SOURCE );
484
485        $ds_ip         = $ds_fields[0];
486        $ds_port       = $ds_fields[1];
487
488        $this->ip       = $ds_ip;
489        $this->port     = $ds_port;
490        $this->clustername = $clustername;
491    }
492
493    function getData()
494    {
495        $errstr        = '';
496        $errno         = 0;
497        $timeout       = 3;
498
499        $fp = fsockopen( $this->ip, $this->port, $errno, $errstr, $timeout );
500
501        if( !$fp )
502        {
503            echo 'Unable to connect to '.$this->ip.':'.$this->port;
504            return;
505        }
506
507        if( $this->port == '8652' )
508        {
509            $request = "/" . $this->clustername . "\n";
510            $rc = fputs($fp, $request);
511            if (!$rc)
512            {
513                $error = "Could not sent request to gmetad: $errstr";
514                if ($debug) print "<br/>DEBUG: $error\n";
515                   return FALSE;
516            }
517        }
518
519        stream_set_timeout( $fp, 30 );
520
521        while ( !feof( $fp ) )
522        {
523            $data .= fread( $fp, 16384 );
524        }
525
526        fclose( $fp );
527
528        return $data;
529    }
530}
531
532class DataGatherer
533{
534    var $xmlhandler, $data, $httpvars;
535
536    function DataGatherer( $cluster )
537    {
538        $this->cluster    = $cluster;
539        $this->httpvars = $httpvars;
540    }
541
542    function parseXML( $data )
543    {
544
545        $this->parser         = xml_parser_create();
546        $this->xmlhandler     = new TorqueXMLHandler( $this->cluster );
547
548        xml_parser_set_option( $this->parser, XML_OPTION_CASE_FOLDING, 0 );
549        xml_set_element_handler( $this->parser, array( &$this->xmlhandler, 'startElement' ), array( &$this->xmlhandler, 'stopElement' ) );
550
551        if ( !xml_parse( $this->parser, $data ) )
552        {
553            $error = sprintf( 'XML error: %s at %d', xml_error_string( xml_get_error_code( $this->parser ) ), xml_get_current_line_number( $this->parser ) );
554        }
555        $handler = &$this->xmlhandler;
556        $handler->finishUp();
557    }
558
559    function printInfo()
560    {
561        $handler = $this->xmlhandler;
562        $handler->printInfo();
563    }
564
565    function getUsingFQDN()
566    {
567        $handler = $this->xmlhandler;
568        return $handler->getUsingFQDN();
569    }
570
571    function getMetrics()
572    {
573        $handler = $this->xmlhandler;
574        return $handler->getMetrics();
575    }
576    function getNodes()
577    {
578        $handler = $this->xmlhandler;
579        return $handler->getNodes();
580    }
581
582    function getNode( $node )
583    {
584        $handler = $this->xmlhandler;
585        return $handler->getNode( $node );
586    }
587
588    function getCpus()
589    {
590        $handler = $this->xmlhandler;
591        return $handler->getCpus();
592    }
593
594    function getJobs()
595    {
596        $handler = $this->xmlhandler;
597        return $handler->getJobs();
598    }
599
600    function getJob( $job )
601    {
602        $handler = $this->xmlhandler;
603        return $handler->getJob( $job );
604    }
605
606    function getHeartbeat()
607    {
608        $handler = $this->xmlhandler;
609        return $handler->getHeartbeat();
610    }
611
612    function isJobmonRunning()
613    {
614        $handler = $this->xmlhandler;
615        return $handler->isJobmonRunning();
616    }
617}
618
619class TorqueXMLHandler
620{
621    var $clusters, $heartbeat, $nodes, $jobs, $clustername, $proc_cluster;
622
623    function TorqueXMLHandler( $clustername )
624    {
625        $this->jobs        = array();
626        $this->clusters     = array();
627        $this->nodes         = array();
628        $this->metrics      = array();
629        $this->heartbeat     = array();
630        $this->down_nodes    = array();
631        $this->offline_nodes    = array();
632        $this->clustername    = $clustername;
633        $this->proc_cluster = null;
634        $this->proc_hostname = null;
635        $this->fqdn        = 1;
636    }
637
638    function getUsingFQDN()
639    {
640        return $this->fqdn;
641    }
642
643    function getCpus()
644    {
645        $cpus = 0;
646
647        if( isset( $this->jobs ) && count( $this->jobs ) > 0 )
648        {
649            foreach( $this->jobs as $jobid=>$jobattrs )
650            {
651                $nodes    = count( $jobattrs['nodes'] );
652                $ppn    = (int) $jobattrs['ppn'] ? $jobattrs['ppn'] : 1;
653                $mycpus    = $nodes * $ppn;
654
655                $cpus    = $cpus + $mycpus;
656            }
657        }
658    }
659
660    function isJobmonRunning()
661    {
662        if (isset( $this->heartbeat['time'] ))
663        {
664            return 1;
665        }
666        else
667        {
668            return 0;
669        }
670    }
671
672    function makeHostname( $thostname, $tdomain=null )
673    {
674        // Should hostname be FQDN or short w/o domain
675        //
676        $nodes = &$this->nodes;
677
678        $fqdn = 1;
679
680        //$tdomain = explode( '.', $thostname );
681        //
682        // TODO?: extract domain from hostname or something?
683
684        if( $tdomain )
685        {
686            $domain_len    = 0 - strlen( $tdomain );
687
688            // Let's see if Ganglia use's FQDN or short hostnames
689            //
690            foreach( $nodes as $hostname => $nimage )
691            {
692                if( strpos( $hostname, $tomdain ) !== false )
693                {
694                    $fqdn    = 0;
695                }
696            }
697        }
698        else
699        {
700            $fqdn    = 0;
701        }
702   
703        if( $tdomain && $fqdn )
704        {
705            if( strpos( $thostname, $tdomain ) !== false )
706            {
707                $thostname = $thostname . '.'.$tdomain;
708            } 
709            else
710            {
711                $thostname = $thostname;
712            }
713        }
714
715        return $thostname;
716    }
717
718    function startElement( $parser, $name, $attrs )
719    {
720        global $cluster, $metrics;
721
722        $jobid = null;
723
724        if( $name == 'CLUSTER' )
725        {
726            // ganglia start
727            $cluster = $attrs;
728            // ganglia end
729
730            $this->proc_cluster = $attrs['NAME'];
731            //printf("set proc cluster to %s\n", $attrs['NAME'] );
732            return null;
733        }
734        if( $this->proc_cluster != $this->clustername )
735        {
736            //printf("cluster does not match: %s\n", $this->clustername );
737            return null;
738        }
739
740        if( $name == 'HOST' )
741        {
742            // ganglia start
743            $hostname = $attrs['NAME'];
744            $this->proc_hostname = $hostname;
745
746            # Pseudo metrics - add useful HOST attributes like gmond_started & last_reported to the metrics list:
747            $metrics[$hostname]['gmond_started']['NAME'] = "GMOND_STARTED";
748            $metrics[$hostname]['gmond_started']['VAL'] = $attrs['GMOND_STARTED'];
749            $metrics[$hostname]['gmond_started']['TYPE'] = "timestamp";
750            $metrics[$hostname]['last_reported']['NAME'] = "REPORTED";
751            $metrics[$hostname]['last_reported']['VAL'] = uptime($cluster['LOCALTIME'] - $attrs['REPORTED']);
752            $metrics[$hostname]['last_reported']['TYPE'] = "string";
753            $metrics[$hostname]['last_reported_timestamp']['NAME'] = "REPORTED TIMESTAMP";
754            $metrics[$hostname]['last_reported_timestamp']['VAL'] = $attrs['REPORTED'];
755            $metrics[$hostname]['last_reported_timestamp']['TYPE'] = "uint32";
756            $metrics[$hostname]['ip_address']['NAME'] = "IP";
757            $metrics[$hostname]['ip_address']['VAL'] = $attrs['IP'];
758            $metrics[$hostname]['ip_address']['TYPE'] = "string";
759            $metrics[$hostname]['location']['NAME'] = "LOCATION";
760            $metrics[$hostname]['location']['VAL'] = $attrs['LOCATION'];
761            $metrics[$hostname]['location']['TYPE'] = "string";
762            // ganglia end
763
764            //printf( "host %s\n", $hostname );
765            //$location = $attrs['LOCATION'];
766
767            if( !isset( $this->nodes[$hostname] ) )
768            {
769                $this->nodes[$hostname] = new NodeImage( $this->proc_cluster, $hostname );
770            }
771            return null;
772        }
773
774        if( $name == 'METRIC' )
775        {
776            $hostname = $this->proc_hostname;
777
778            // ganglia start
779            $metricname = rawurlencode($attrs['NAME']);
780            $metrics[$hostname][$metricname] = $attrs;
781            // ganglia end
782
783            if ( strpos( $attrs['NAME'], 'zplugin_monarch' ) === false )
784            {
785                return null;
786            }
787
788            if( strpos( $attrs['NAME'], 'zplugin_monarch_heartbeat' ) !== false )
789            {
790                $this->heartbeat['time'] = $attrs['VAL'];
791                return;
792            }
793            else if( strpos( $attrs['NAME'], 'zplugin_monarch_down' ) !== false )
794            {
795                $fields        = explode( ' ', $attrs['VAL'] );
796
797                $nodes_down    = array();
798                $down_domain    = null;
799
800                foreach( $fields as $f )
801                {
802                    $togavalues    = explode( '=', $f );
803
804                    $toganame    = $togavalues[0];
805                    $togavalue    = $togavalues[1];
806
807                    if( $toganame == 'nodes' )
808                    {
809                        $mynodes = explode( ';', $togavalue );
810
811                        foreach( $mynodes as $node )
812                        {
813                            $nodes_down[] = $node;
814                        }
815                    }
816                    else if( $toganame == 'domain' )
817                    {
818                        $down_domain = $togavalue;
819                    }
820                    else if( $toganame == 'reported' )
821                    {
822                        if( !isset( $this->down_nodes['heartbeat'] ) )
823                        {
824                            $this->down_nodes[$togavalue]    = array( $nodes_down, $down_domain );
825                        }
826                    }
827                }
828                return;
829            }
830            else if( strpos( $attrs['NAME'], 'zplugin_monarch_offline' ) !== false )
831            {
832                $fields        = explode( ' ', $attrs['VAL'] );
833
834                $nodes_offline    = array();
835                $offline_domain    = null;
836
837                foreach( $fields as $f )
838                {
839                    $togavalues    = explode( '=', $f );
840
841                    $toganame    = $togavalues[0];
842                    $togavalue    = $togavalues[1];
843
844                    if( $toganame == 'nodes' )
845                    {
846                        $mynodes = explode( ';', $togavalue );
847
848                        foreach( $mynodes as $node )
849                        {
850                            $nodes_offline[] = $node;
851                        }
852                    }
853                    else if( $toganame == 'domain' )
854                    {
855                        $offline_domain = $togavalue;
856                    }
857                    else if( $toganame == 'reported' )
858                    {
859                        if( !isset( $this->offline_nodes['heartbeat'] ) )
860                        {
861                            $this->offline_nodes[$togavalue] = array( $nodes_offline, $offline_domain );
862                        }
863                    }
864                }
865                return;
866            }
867            else if( strpos( $attrs['NAME'], 'zplugin_monarch_job' ) !== false )
868            {
869                sscanf( $attrs['NAME'], 'zplugin_monarch_job_%d_%s$', $monincr, $jobid );
870
871                if( !isset( $this->jobs[$jobid] ) )
872                {
873                    $this->jobs[$jobid] = array();
874                }
875
876                $fields = explode( ' ', $attrs['VAL'] );
877
878                foreach( $fields as $f )
879                {
880                    $togavalues = explode( '=', $f );
881
882                    $toganame = $togavalues[0];
883                    $togavalue = $togavalues[1];
884
885                    if( $toganame == 'nodes' )
886                    {
887                        if( $this->jobs[$jobid]['status'] == 'R' )
888                        {
889                            if( !isset( $this->jobs[$jobid][$toganame] ) )
890                            {
891                                $this->jobs[$jobid][$toganame] = array();
892                            }
893
894                            $mynodes = explode( ';', $togavalue );
895
896                            foreach( $mynodes as $node )
897                            {
898                                if( !in_array( $node, $this->jobs[$jobid][$toganame] ) )
899                                {
900                                    array_push( $this->jobs[$jobid][$toganame], $node );
901                                }
902                            }
903
904                        }
905                        else if( $this->jobs[$jobid]['status'] == 'Q' )
906                        {
907                            $this->jobs[$jobid][$toganame] = $togavalue;
908                        }
909                    }
910                    else
911                    {
912                        $this->jobs[$jobid][$toganame] = $togavalue;
913                    }
914                }
915
916                if( isset( $this->jobs[$jobid]['nodes'] ) )
917                {
918                    $nr_nodes = count( $this->jobs[$jobid]['nodes'] );
919       
920                    if( $this->jobs[$jobid]['status'] == 'R' )
921                    {
922
923                        if( isset( $this->jobs[$jobid]['domain'] ) )
924                        {
925                            $domain        = $this->jobs[$jobid]['domain'];
926                            $domain_len    = 0 - strlen( $domain );
927
928                            $nodekeys     = array_keys( $this->nodes );
929
930                            $first_host    = $nodekeys[0];
931                            // Let's see if Ganglia use's FQDN or short hostnames
932                            //
933                            if( strpos( $first_host, $domain ) === false )
934                            {
935                                $this->fqdn    = 0;
936                            }
937                        }
938                        else
939                        {
940                            $this->fqdn    = 0;
941                        }
942
943                        foreach( $this->jobs[$jobid]['nodes'] as $node )
944                        {
945
946                            // Only add domain name to the hostname if Ganglia is doing that too
947                            //
948                            if( $this->fqdn && isset( $this->jobs[$jobid]['domain'] ) )
949                            {
950                                if( strpos( $node, $domain ) === false )
951                                {
952                                    $host = $node. '.'.$domain;
953                                } else
954                                {
955                                    $host = $node;
956                                }
957                            }
958                            else
959                            {
960                                $host    = $node;
961                            }
962
963                            if( !isset( $this->nodes[$host] ) )
964                            {
965                                $my_node = new NodeImage( $this->proc_cluster, $host );
966                            }
967                            else
968                            {
969                                $my_node = $this->nodes[$host];
970                            }
971
972                            if( !$my_node->hasJob( $jobid ) )
973                            {
974                                if( isset( $jobs[$jobid]['ppn'] ) )
975                                {
976                                    $my_node->addJob( $jobid, ((int) $jobs[$jobid]['ppn']) );
977                                }
978                                else
979                                {
980                                    $my_node->addJob( $jobid, 1 );
981                                }
982                            }
983
984                            $this->nodes[$host] = $my_node;
985                        }
986                    }
987                }
988            }
989            return;
990        }
991    }
992
993    function finishUp( )
994    {
995        $nodes    = $this->nodes;
996
997        if( sizeof( $this->down_nodes ) > 0 )
998        {
999            foreach( $this->down_nodes as $reported => $dnodes )
1000            {
1001                if( $reported == $this->heartbeat['time'] )
1002                {
1003                    $domain = $dnodes[1];
1004
1005                    foreach( $dnodes[0] as $downhost )
1006                    {
1007                        $downhost = $this->makeHostname( $downhost, $domain );
1008
1009                        if( isset( $nodes[$downhost] ) )
1010                        {
1011                            // OMG PHP4 is fking stupid!
1012                            // $nodes[$downhost]->setDown( 1 ) won't work here..
1013                            //
1014                            $mynode = $nodes[$downhost];
1015                            $mynode->setDown( 1 );
1016                            $nodes[$downhost] = $mynode;
1017                        }
1018                    }
1019                }
1020            }
1021        }
1022
1023        if( sizeof( $this->offline_nodes ) > 0 )
1024        {
1025            foreach( $this->offline_nodes as $reported => $onodes )
1026            {
1027                if( $reported == $this->heartbeat['time'] )
1028                {
1029                    $domain = $onodes[1];
1030
1031                    foreach( $onodes[0] as $offlinehost )
1032                    {
1033                        $offlinehost = $this->makeHostname( $offlinehost, $domain );
1034
1035                        if( isset( $nodes[$offlinehost] ) )
1036                        {
1037                            // OMG PHP4 is fking stupid!
1038                            // $nodes[$offlinehost]->setDown( 1 ) won't work here..
1039                            //
1040                            $mynode = $nodes[$offlinehost];
1041                            $mynode->setOffline( 1 );
1042                            $nodes[$offlinehost] = $mynode;
1043                        }
1044                    }
1045                }
1046            }
1047        }
1048
1049        $this->nodes = $nodes;
1050    }
1051
1052    function stopElement( $parser, $name )
1053    {
1054    }
1055
1056    function printInfo()
1057    {
1058        $jobs = &$this->jobs;
1059
1060        printf( "---jobs---\n" );
1061
1062        foreach( $jobs as $jobid => $job )
1063        {
1064            printf( "job %s\n", $jobid );
1065
1066            if( isset( $job['nodes'] ) )
1067            {
1068                foreach( $job['nodes'] as $node )
1069                {
1070                    $mynode = $this->nodes[$node];
1071                    $hostname = $mynode->getHostname();
1072                    $location = $mynode->getLocation();
1073
1074                    printf( "\t- node %s\tlocation %s\n", $hostname, $location );
1075                }
1076            }
1077        }
1078
1079        printf( "---nodes---\n" );
1080
1081        $nodes = &$this->nodes;
1082
1083        foreach( $nodes as $node )
1084        {
1085            $hostname = $node->getHostname();
1086            $location = $node->getLocation();
1087            $jobs = implode( ' ', $node->getJobs() );
1088            printf( "* node %s\tlocation %s\tjobs %s\n", $hostname, $location, $jobs );
1089        }
1090    }
1091
1092    function getNodes()
1093    {
1094        return $this->nodes;
1095    }
1096
1097    function getNode( $node )
1098    {
1099        $nodes = &$this->nodes;
1100
1101        if( isset( $nodes[$node] ) )
1102        {
1103            return $nodes[$node];
1104        }
1105        else
1106        {
1107            return NULL;
1108        }
1109    }
1110
1111    function getJobs()
1112    {
1113        return $this->jobs;
1114    }
1115
1116    function getJob( $job )
1117    {
1118        $jobs = &$this->jobs;
1119
1120        if( isset( $jobs[$job] ) )
1121        {
1122            return $jobs[$job];
1123        }
1124        else
1125        {
1126            return NULL;
1127        }
1128    }
1129
1130    function getHeartbeat()
1131    {
1132        return $this->heartbeat['time'];
1133    }
1134}
1135
1136class NodeImage
1137{
1138    var $image, $x, $y, $hostname, $jobs, $tasks, $showinfo;
1139
1140    function NodeImage( $cluster, $hostname )
1141    {
1142        global $SMALL_CLUSTERIMAGE_NODEWIDTH;
1143
1144        $this->jobs        = array();
1145        $this->tasks        = 0;
1146        $this->hostname        = $hostname;
1147        $this->clustername    = $cluster;
1148        $this->showinfo        = 1;
1149        $this->size        = $SMALL_CLUSTERIMAGE_NODEWIDTH;
1150        $this->down        = 0;
1151        $this->offline        = 0;
1152    }
1153
1154    function addJob( $jobid, $cpus )
1155    {
1156        $jobs        = &$this->jobs;
1157        $jobs[]        = $jobid;
1158        $this->jobs    = $jobs;
1159
1160        $this->addTask( $cpus );
1161    }
1162
1163    function hasJob( $jobid )
1164    {
1165        $jobfound = 0;
1166
1167        if( count( $this->jobs ) > 0 )
1168        {
1169            foreach( $this->jobs as $job )
1170            {
1171                if( $job == $jobid )
1172                {
1173                    $jobfound = 1;
1174                }
1175            }
1176        }
1177
1178        return $jobfound;
1179    }
1180
1181    function addTask( $cpus )
1182    {
1183        $this->tasks = $this->tasks + $cpus;
1184    }
1185    function setDown( $down )
1186    {
1187        $this->down = $down;
1188    }
1189    function isDown()
1190    {
1191        return $this->down;
1192    }
1193    function setOffline( $offline )
1194    {
1195        $this->offline = $offline;
1196    }
1197    function isOffline()
1198    {
1199        return $this->offline;
1200    }
1201    function setImage( $image )
1202    {
1203        $this->image = $image;
1204    }
1205    function setCoords( $x, $y )
1206    {
1207        $this->x = $x;
1208        $this->y = $y;
1209    }
1210    function getX()
1211    {
1212        return $this->x;
1213    }
1214    function getY()
1215    {
1216        return $this->y;
1217    }
1218
1219    function getImagemapArea()
1220    {
1221        $area_topleft        = $this->x . "," . $this->y;
1222        $area_bottomright    = ($this->x + $this->size) . "," . ($this->y + $this->size);
1223        $area_coords        = $area_topleft . "," . $area_bottomright;
1224
1225        $area_href        = "./?c=" . $this->clustername . "&h=" . $this->hostname;
1226
1227        $area_tooltip        = $this->hostname;
1228
1229        if( $this->down)
1230        {
1231            $area_tooltip        = $area_tooltip . ": DOWN";
1232        }
1233        else if( $this->offline )
1234        {
1235            $area_tooltip        = $area_tooltip . ": OFFLINE";
1236        }
1237
1238        $area_tooltip        = $area_tooltip . ": " . implode( " ", $this->jobs );
1239
1240        $tag_href        = "HREF=\"" . $area_href . "\"";
1241        $tag_coords        = "COORDS=\"" . $area_coords . "\"";
1242        $tag_tooltip1        = "ALT=\"" . $area_tooltip . "\"";
1243        $tag_tooltip2        = "TITLE=\"" . $area_tooltip . "\"";
1244
1245        return ("<AREA SHAPE=\"RECT\" " . $tag_coords . " " . $tag_href . " " . $tag_tooltip1 . " " . $tag_tooltip2 . ">");
1246    }
1247
1248    function colorHex( $color )
1249    {
1250        $my_color = imageColorAllocate( $this->image, hexdec( substr( $color, 0, 2 )), hexdec( substr( $color, 2, 2 )), hexdec( substr( $color, 4, 2 )) );
1251
1252        return $my_color;
1253    }
1254
1255    function setLoad( $load )
1256    {
1257        $this->load = $load;
1258    }
1259
1260    function setHostname( $hostname )
1261    {
1262        $this->hostname = $hostname;
1263    }
1264
1265    function getHostname()
1266    {
1267        return $this->hostname;
1268    }
1269
1270    function getJobs()
1271    {
1272        return $this->jobs;
1273    }
1274
1275    function setShowinfo( $showinfo )
1276    {
1277        $this->showinfo = $showinfo;
1278    }
1279
1280    function drawSmall()
1281    {
1282        global $SMALL_CLUSTERIMAGE_NODEWIDTH;
1283
1284        $this->size    = $SMALL_CLUSTERIMAGE_NODEWIDTH;
1285
1286        $this->draw();
1287    }
1288
1289    function drawBig()
1290    {
1291        global $BIG_CLUSTERIMAGE_NODEWIDTH;
1292
1293        $this->size    = $BIG_CLUSTERIMAGE_NODEWIDTH;
1294
1295        $this->draw();
1296    }
1297
1298    function draw()
1299    {
1300        global $JOB_NODE_MARKING, $NODE_DOWN_MARKING, $NODE_OFFLINE_MARKING;
1301
1302        $black_color = imageColorAllocate( $this->image, 0, 0, 0 );
1303        $size = $this->size;
1304
1305        imageFilledRectangle( $this->image, $this->x, $this->y, $this->x+($size), $this->y+($size), $black_color );
1306
1307        if( $this->showinfo)
1308        {
1309            $this->load = $this->determineLoad();
1310
1311            if( !isset( $this->image ) or !isset( $this->x ) or !isset( $this->y ) )
1312            {
1313                printf( "aborting\n" );
1314                printf( "x %d y %d load %f\n", $this->x, $this->y, $load );
1315                return;
1316            }
1317
1318            // Convert Ganglias Hexadecimal load color to a Decimal one
1319            //
1320            $load = $this->determineLoad();   
1321            $usecolor = $this->colorHex( load_color($load) );
1322            imageFilledRectangle( $this->image, $this->x+1, $this->y+1, $this->x+($size-1), $this->y+($size-1), $usecolor );
1323            if( $this->down )
1324            {
1325                imageString( $this->image, 1, $this->x+(($size/2)-1), $this->y+(($size/2)-4), $NODE_DOWN_MARKING, $black_color );
1326            }
1327            else if( $this->offline )
1328            {
1329                imageString( $this->image, 1, $this->x+(($size/2)-1), $this->y+(($size/2)-4), $NODE_OFFLINE_MARKING, $black_color );
1330            }
1331            else if( count( $this->jobs ) > 0 )
1332            {
1333                imageString( $this->image, 1, $this->x+(($size/2)-1), $this->y+(($size/2)-4), $JOB_NODE_MARKING, $black_color );
1334            }
1335        }
1336        else
1337        {
1338            // White
1339            $usecolor = imageColorAllocate( $this->image, 255, 255, 255 );
1340            imageFilledRectangle( $this->image, $this->x+1, $this->y+1, $this->x+($size-1), $this->y+($size-1), $usecolor );
1341        }
1342    }
1343
1344    function determineLoad()
1345    {
1346        global $metrics;
1347
1348        $cpus = $metrics[$this->hostname]['cpu_num']['VAL'];
1349        if (!$cpus)
1350        {
1351            $cpus=1;
1352        }
1353
1354        $load_one    = $metrics[$this->hostname]['load_one']['VAL'];
1355        $load        = ((float) $load_one)/$cpus;
1356
1357        return $load;
1358    }
1359}
1360
1361class ClusterImage
1362{
1363    var $dataget, $image, $clustername;
1364    var $filtername, $filters;
1365
1366    function ClusterImage( $data, $clustername )
1367    {
1368        $this->dataget        = new DataGatherer( $clustername );
1369        $this->data        = $data;
1370        $this->clustername    = $clustername;
1371        $this->filters        = array();
1372        $this->size        = 's';
1373        $this->width        = 0;
1374        $this->height        = 0;
1375        $this->output        = 1;
1376        $this->jobs         = null;
1377        $this->nodes        = null;
1378    }
1379
1380    function getWidth()
1381    {
1382        return $this->width;
1383    }
1384    function getHeight()
1385    {
1386        return $this->height;
1387    }
1388    function setSmall()
1389    {
1390        $this->size    = 's';
1391    }
1392    function setBig()
1393    {
1394        $this->size    = 'b';
1395    }
1396    function setNoimage()
1397    {
1398        $this->output    = 0;
1399    }
1400    function setJobs($jobs )
1401    {
1402        $this->jobs     = &$jobs;
1403    }
1404    function getJobs()
1405    {
1406        if( $this->jobs == null )
1407        {
1408            $mydatag = $this->dataget;
1409            $mydatag->parseXML( $this->data );
1410            $this->jobs = $mydatag->getJobs();
1411        }
1412
1413        return $this->jobs;
1414    }
1415    function getNodes()
1416    {
1417        if( $this->nodes== null )
1418        {
1419            $mydatag = $this->dataget;
1420            $mydatag->parseXML( $this->data );
1421            $this->nodes = $mydatag->getNodes();
1422        }
1423
1424        return $this->nodes;
1425    }
1426    function setNodes($nodes)
1427    {
1428        $this->nodes    = &$nodes;
1429    }
1430    function isSmall()
1431    {
1432        return ($this->size == 's');
1433    }
1434    function isBig()
1435    {
1436        return ($this->size == 'b');
1437    }
1438    function setFilter( $filtername, $filtervalue )
1439    {
1440        $this->filters[$filtername] = $filtervalue;
1441    }
1442
1443    function filterNodes( $jobs, $nodes )
1444    {
1445        $filtered_nodes = array();
1446
1447        //print_r( $nodes );
1448
1449        foreach( $nodes as $node )
1450        {
1451            $hostname = $node->getHostname();
1452
1453            $addhost = 1;
1454
1455            if( count( $this->filters ) > 0 )
1456            {
1457                $mynjobs = $node->getJobs();
1458
1459                if( count( $mynjobs ) > 0 )
1460                {
1461                    foreach( $mynjobs as $myjob )
1462                    {
1463                        foreach( $this->filters as $filtername => $filtervalue )
1464                        {
1465                            if( $filtername!=null && $filtername!='' )
1466                            {
1467                                if( $filtername == 'jobid' && !$node->hasJob( $filtervalue) )
1468                                {
1469                                    $addhost = 0;
1470                                }
1471                                else if( $filtername != 'jobid' )
1472                                {
1473                                    if( $jobs[$myjob][$filtername] != $filtervalue )
1474                                    {
1475                                        $addhost = 0;
1476                                    }
1477                                }
1478                            }
1479                        }
1480                    }
1481                }
1482                else
1483                {
1484                    $addhost = 0;
1485                }
1486            }
1487
1488            if( $addhost )
1489            {
1490                $filtered_nodes[] = $hostname;
1491            }
1492        }
1493
1494        return $filtered_nodes;
1495    }
1496
1497    function draw()
1498    {
1499        global $SMALL_CLUSTERIMAGE_MAXWIDTH, $SMALL_CLUSTERIMAGE_NODEWIDTH;
1500        global $BIG_CLUSTERIMAGE_MAXWIDTH, $BIG_CLUSTERIMAGE_NODEWIDTH;
1501        global $CLUSTER_CONFS, $confcluster, $SHOW_EMPTY_COLUMN, $SHOW_EMPTY_ROW;
1502
1503        global $SORTBY_HOSTNAME, $SORT_ORDER, $skan_str;
1504        global $x_first, $y_first;
1505
1506        foreach( $CLUSTER_CONFS as $confcluster => $conffile )
1507        {
1508            if( strtolower( trim($this->clustername) ) == strtolower(trim($confcluster)) )
1509            {
1510                include_once $conffile;
1511            }
1512        }
1513
1514        if( $this->isSmall() )
1515        {
1516            $max_width    = $SMALL_CLUSTERIMAGE_MAXWIDTH;
1517            $node_width    = $SMALL_CLUSTERIMAGE_NODEWIDTH;
1518        }
1519        else if( $this->isBig() )
1520        {
1521            $max_width    = $BIG_CLUSTERIMAGE_MAXWIDTH;
1522            $node_width    = $BIG_CLUSTERIMAGE_NODEWIDTH;
1523        }
1524
1525        $nodes        = $this->getNodes();
1526        $nodes_hosts    = array_keys( $nodes );
1527
1528        $nodes_nr    = count( $nodes );
1529
1530        $nodes_size    = $nodes_nr*$node_width;
1531        $node_rows    = 0;
1532
1533        if( $nodes_size > $max_width )
1534        {
1535            $nodes_per_row = ( (int) ($max_width/$node_width) );
1536        }
1537        else
1538        {
1539            $nodes_per_row = $nodes_size;
1540            $node_rows = 1;
1541        }
1542
1543        if( $nodes_per_row < $nodes_nr )
1544        {
1545            $node_rows = ( (int) ($nodes_nr/$nodes_per_row) );
1546            $node_rest = fmod( $nodes_nr, $nodes_per_row );
1547
1548            if( $node_rest > 0 )
1549            {
1550                $node_rows++;
1551            }
1552        }
1553
1554        $y_offset    = 0;
1555        $font         = 2;
1556        $fontwidth    = ImageFontWidth( $font );
1557        $fontheight    = ImageFontHeight( $font );
1558        $fontspaceing    = 2;
1559        $y_offset    = $fontheight + (2 * $fontspaceing);
1560
1561        $this->width    = $max_width;
1562        $this->height    = ($y_offset + (($node_rows*$node_width)+1) );
1563
1564        $jobs = $this->getJobs();
1565        $filtered_nodes = $this->filterNodes( $jobs, $nodes );
1566
1567        if( $SORTBY_HOSTNAME != "" )
1568        {
1569                $sorted     = array();
1570
1571            $x_first    = 0;
1572            $y_first    = 0;
1573
1574            $skan_str    = $SORTBY_HOSTNAME;
1575
1576            global $x_present, $y_present;
1577            $x_present    = false;
1578            $y_present    = false;
1579
1580            // Should we scan by X, Y or both
1581            //
1582            if(strpos( $SORTBY_HOSTNAME, "{x}" ) != false )
1583            {
1584                $x_str        = "{x}";
1585                $x_present    = true;
1586            }
1587            else if(strpos( $SORTBY_HOSTNAME, "{X}" ) != false )
1588            {
1589                $x_str        = "{X}";
1590                $x_present    = true;
1591            }
1592            if(strpos( $SORTBY_HOSTNAME, "{y}" ) != false )
1593            {
1594                $y_str        = "{y}";
1595                $y_present    = true;
1596            }
1597            else if(strpos( $SORTBY_HOSTNAME, "{Y}" ) != false )
1598            {
1599                $y_str        = "{Y}";
1600                $y_present    = true;
1601            }
1602
1603            // If we should scan for both X and Y: see which one is first
1604            //
1605            if(( strpos( $SORTBY_HOSTNAME, $x_str ) < strpos( $SORTBY_HOSTNAME, $y_str ) ) && ( $x_present && $y_present ))
1606            {
1607                $x_first    = 1;
1608            }
1609            else if(( strpos( $SORTBY_HOSTNAME, $x_str ) > strpos( $SORTBY_HOSTNAME, $y_str ) ) && ( $x_present && $y_present ))
1610            {
1611                $y_first    = 1;
1612       
1613            }
1614            else if( $x_present )
1615            {
1616                $x_first    = 1;
1617            }
1618            else if( $y_present )
1619            {
1620                $y_first    = 1;
1621            }
1622
1623            // Now replace our {x} and {y} with %d for sscanf parsing
1624            //
1625            if(( $x_first ) && ( $x_present && $y_present ) )
1626            {
1627                $skan_str    = str_replace( $x_str, "%d", $skan_str );
1628                $skan_str    = str_replace( $y_str, "%d", $skan_str );
1629            } 
1630            else if( $x_present)
1631            {
1632                $skan_str    = str_replace( $x_str, "%d", $skan_str );
1633            }
1634            else if( $y_present)
1635            {
1636                $skan_str    = str_replace( $y_str, "%d", $skan_str );
1637            }
1638
1639            $x_min        = null;
1640            $x_max        = null;
1641            $y_min        = null;
1642            $y_max        = null;
1643
1644            $x_columns    = array();
1645            $y_rows        = array();
1646
1647            // Now let's walk through all our nodes and see which one are valid for our scan pattern
1648            //
1649            foreach( $nodes as $hostname => $node )
1650            {
1651                $x    = null;
1652                $y    = null;
1653
1654                if( $x_present && $y_present )
1655                {
1656                    if( $x_first )
1657                    {
1658                        $n = sscanf( $hostname, $skan_str, $x, $y );
1659                    }
1660                    else if( $y_first )
1661                    {
1662                        $n = sscanf( $hostname, $skan_str, $y, $x );
1663                    }
1664
1665                    // Remove nodes that don't match
1666                    //
1667                    if( $n < 2 )
1668                    {
1669                        // This node hostname has no match for: {x} and {y}
1670                        //
1671                        unset( $nodes[$hostname] );
1672                    }
1673                }
1674                else if( $x_present && !$y_present )
1675                {
1676                    $n = sscanf( $hostname, $skan_str, $x );
1677
1678                    // Remove nodes that don't match
1679                    //
1680                    if( $n < 1 )
1681                    {
1682                        // This node hostname has no match for: {x}
1683                        //
1684                        unset( $nodes[$hostname] );
1685                    }
1686                    $y    = 1;
1687                }
1688                else if( $y_present && !$x_present )
1689                {
1690                    $n = sscanf( $hostname, $skan_str, $y );
1691
1692                    // Remove nodes that don't match
1693                    //
1694                    if( $n < 1 )
1695                    {
1696                        // This node hostname has no match for: {y}
1697                        //
1698                        unset( $nodes[$hostname] );
1699                    }
1700                    $x    = 1;
1701                }
1702
1703                // Determine the lowest value of {x} that exists in all node hostnames
1704                //
1705                if( !$x_min && $x != null )
1706                {
1707                    $x_min    = $x;
1708                }
1709                else if( $x < $x_min && $x != null )
1710                {
1711                    $x_min    = $x;
1712                }
1713
1714                // Determine the highest value of {x} that exists in all node hostnames
1715                //
1716                if( !$x_max && $x != null )
1717                {
1718                    $x_max    = $x;
1719                }
1720                else if( $x > $x_max && $x != null )
1721                {
1722                    $x_max    = $x;
1723                }
1724
1725                // Determine the lowest value of {y} that exists in all node hostnames
1726                //
1727                if( !$y_min && $y != null )
1728                {
1729                    $y_min    = $y;
1730                }
1731                else if( $y < $y_min && $y != null )
1732                {
1733                    $y_min    = $y;
1734                }
1735
1736                // Determine the highest value of {y} that exists in all node hostnames
1737                //
1738                if( !$y_max && $y != null )
1739                {
1740                    $y_max    = $y;
1741                }
1742                else if( $y > $y_max && $y != null )
1743                {
1744                    $y_max    = $y;
1745                }
1746
1747                // Store which non-empty columns and rows we found
1748                //
1749                if( !in_array( $x, $x_columns ) )
1750                {
1751                    $x_columns[] = $x;
1752                }
1753                if( !in_array( $y, $y_rows ) )
1754                {
1755                    $y_rows[] = $y;
1756                }
1757            }
1758
1759            // Sort all the nodes (alpha and numerically)
1760            // 1: gb-r1n1, 2: gb-r1n2, 3: gb-r2n1, etc
1761            //
1762            $sorted_nodes    = usort( $nodes, "cmp" );
1763
1764            //print_r( $x_columns ) ;
1765
1766            $cur_node    = 0;
1767
1768            $x_offset    = 0;
1769            $y_offset    = 0;
1770            $font         = 2;
1771            $fontwidth    = ImageFontWidth( $font );
1772            $fontheight    = ImageFontHeight( $font );
1773            $fontspaceing    = 2;
1774
1775            if( $this->isSmall() ) 
1776            {
1777                $y_offset    = $y_offset + (2 * $fontspaceing) + $fontheight;
1778            }
1779
1780            if( $this->isBig() ) 
1781            {
1782                $y_offset    = ($fontheight * (1 + strlen( $x_max) ) ) + ((2 + strlen( $x_max)) * $fontspaceing);
1783                $x_offset    = ($fontwidth * (1 + strlen( $y_max) ) ) + ((2 + strlen( $y_max)) * $fontspaceing);
1784            }
1785
1786            $image_width    = $x_offset + ($node_width * ($x_max-$x_min+2));
1787
1788            if( $this->isSmall() ) 
1789            {
1790                $image_width    = $max_width;
1791            }
1792            else if( $this->isBig() ) 
1793            {
1794                $image_width    = ($image_width < $max_width) ? $image_width : $max_width;
1795            }
1796            $image_height    = $y_offset + ($node_width * ($y_max-$y_min+2));
1797
1798            $this->width    = $image_width;
1799            $this->heigth    = $image_heigth;
1800
1801            $image        = imageCreateTrueColor( $image_width, $image_height );
1802            $colorwhite    = imageColorAllocate( $image, 255, 255, 255 );
1803
1804            imageFill( $image, 0, 0, $colorwhite );
1805
1806            if( $this->isSmall() )
1807            {
1808                // Draw a fancy little header text to explain what it is
1809                //
1810                $colorblue    = imageColorAllocate( $image, 0, 0, 255 );
1811
1812                imageString( $image, $font, 2, 2, "Monarch Joblist - cluster: ".$this->clustername, $colorblue );
1813            }
1814
1815            if( $this->isBig() && ( isset( $SORT_XLABEL ) || isset( $SORT_YLABEL ) ) )
1816            {
1817                $colorblue    = imageColorAllocate( $image, 0, 0, 255 );
1818
1819                if( isset( $SORT_XLABEL ) )
1820                {
1821                    // Print the {x} label: rack
1822                    //
1823                    imageString( $image, $font, $x_offset, $fontspaceing, $SORT_XLABEL, $colorblue );
1824                }
1825
1826                if( isset( $SORT_YLABEL ) )
1827                {
1828                    // Stupid php without imageStringDown function... we'll make one ourself
1829                    //
1830
1831                    // Print the {y} label: node
1832                    //
1833                    imageStringDown( $image, $font, $fontspaceing, $y_offset, $SORT_YLABEL, $colorblue );
1834                }
1835            }
1836
1837            $previous_n    = 0;
1838            $previous_m    = 0;
1839            $x_empty_count    = 0;
1840            $y_empty_count    = 0;
1841
1842            // Let's start assigning x,y coordinates now
1843            //
1844            for( $n = $x_min; $n <= $x_max; $n++ )
1845            {
1846                for( $m = $y_min; $m <= $y_max; $m++ )
1847                {
1848                    if( $x_min > 0 )
1849                    {
1850                        $x    = $x_offset + ( ($n-$x_min) * $node_width ) - ($x_empty_count * $node_width);
1851                    }
1852                    if( $y_min > 0 )
1853                    {
1854                        $y    = $y_offset + ( ($m-$y_min) * $node_width ) - ($y_empty_count * $node_width);
1855                    }
1856
1857                    // Don't show empty rows/columns if option enabled
1858                    //
1859                    if( !in_array( $n, $x_columns ) && !$SHOW_EMPTY_COLUMN )
1860                    {
1861                        // Skip to next iteration: we don't want a empty column
1862                        //
1863                        if( $n > $previous_n )
1864                        {
1865                            $previous_n = $n;
1866                            $x_empty_count++;
1867                        }
1868                        continue;
1869                    }
1870                    if( !in_array( $m, $y_rows ) && !$SHOW_EMPTY_ROW )
1871
1872                    {
1873                        // Skip to next iteration: we don't want a empty column
1874                        //
1875                        if( $m > $previous_m )
1876                        {
1877                            $previous_m = $m;
1878                            $y_empty_count++;
1879                        }
1880                        continue;
1881                    }
1882
1883                    if( $this->isBig() ) 
1884                    {
1885                        // Draw y(node) column number header
1886                        //
1887                        if(( $n == $x_min ) && ( isset($SORT_YLABEL) ) )
1888                        {
1889                            $mfontspacing    = 1;
1890
1891                            $ylabel_x    = $x - ( $fontwidth * strlen( $y_max ) ) - $mfontspacing;
1892                            $ylabel_y    = $y;
1893
1894                            imageString( $image, $font, $ylabel_x, $ylabel_y, strval( $m ), $colorblue );
1895
1896                            $xmin_hit[$n]    = true;
1897                        }
1898
1899                        // Draw x(rack) column number header
1900                        //
1901                        if(( $m == $y_min ) && ( isset($SORT_XLABEL) ) )
1902                        {
1903                            $mfontspacing    = 2;
1904                            $xlabel_y    = $y - ( $fontheight * strlen( $x_max ) );
1905                            $xlabel_x    = $x + $mfontspacing; 
1906
1907                            imageStringDown( $image, $font, $xlabel_x, $xlabel_y, strval( $n ), $colorblue );
1908                        }
1909                    }
1910
1911                    if( isset( $nodes[$cur_node] ) ) 
1912                    {
1913                        $host    = $nodes[$cur_node]->getHostname();
1914
1915                        if( $x_present && $y_present )
1916                        {
1917                            if( $x_first )
1918                            {
1919                                $nn = sscanf( $host, $skan_str, $rx, $ry );
1920                            }
1921                            else if( $y_first )
1922                            {
1923                                $nn = sscanf( $host, $skan_str, $ry, $rx );
1924                            }
1925                            if ( $nn < 2 )
1926                            {
1927                                //printf( "skipping node %s - y present & x present + <2 x,y matchs\n", $host);
1928                                continue;
1929                            }
1930                            if( intval( $rx ) > $n )
1931                            {
1932                                // If x(rack) is higher than current x, skip to next x(rack)
1933                                //
1934                                $m        = $y_max + 1;
1935
1936                                continue;
1937                            }
1938                            if( intval( $ry ) > $m )
1939                            {
1940                                // If y(node) is higher than current y, skip to next y(node)
1941                                //
1942                                continue;
1943                            }
1944                        }
1945                        else if( $x_present )
1946                        {
1947                            $nn = sscanf( $host, $skan_str, $rx );
1948                        }
1949                        else if( $y_present )
1950                        {
1951                            $nn = sscanf( $host, $skan_str, $ry );
1952                        }
1953
1954                        if( !in_array( $host, $filtered_nodes ) )
1955                        {
1956                            // This node has been filtered out: we only want to see certain nodes
1957                            //
1958                            $nodes[$cur_node]->setShowinfo( 0 );
1959                        }
1960
1961                        $nodes[$cur_node]->setCoords( $x, $y );
1962                        $nodes[$cur_node]->setImage( $image );
1963
1964                        if( $this->isSmall() )
1965                        {
1966                            $nodes[$cur_node]->drawSmall();
1967                        }
1968                        else if( $this->isBig() )
1969                        {
1970                            $nodes[$cur_node]->drawBig();
1971                        }
1972
1973                        $cur_node++;
1974                    }
1975                }
1976            }
1977
1978        }
1979        else
1980        {
1981            if( $this->isSmall() )
1982            {
1983                $image        = imageCreateTrueColor( $max_width, ($y_offset + (($node_rows*$node_width)+1) ) );
1984            }
1985            else if( $this->isBig() )
1986            {
1987                $image_width    = ($node_width * $nodes_nr) + 2;
1988                $image_width    = ($image_width < $max_width) ? $image_width : $max_width;
1989                $image        = imageCreateTrueColor( $image_width, ($y_offset + (($node_rows*$node_width)+1) ) );
1990            }
1991            $colorwhite    = imageColorAllocate( $image, 255, 255, 255 );
1992
1993            imageFill( $image, 0, 0, $colorwhite );
1994
1995            if( $this->isSmall() )
1996            {
1997                $colorblue    = imageColorAllocate( $image, 0, 0, 255 );
1998
1999                imageString( $image, $font, 2, 2, "Monarch Joblist - cluster: ".$this->clustername, $colorblue );
2000            }
2001
2002            for( $n = 0; $n < $node_rows; $n++ )
2003            {
2004                for( $m = 0; $m < $nodes_per_row; $m++ )
2005                {
2006                    $x = ($m * $node_width);
2007                    $y = $y_offset + ($n * $node_width);
2008
2009                    $cur_node = ($n * $nodes_per_row) + ($m);
2010                    $host = isset( $nodes_hosts[$cur_node] ) ? $nodes_hosts[$cur_node] : '';
2011
2012                    if( isset( $nodes[$host] ) )
2013                    {
2014                        $nodes[$host]->setCoords( $x, $y );
2015                        $nodes[$host]->setImage( $image );
2016
2017                        if( !in_array( $host, $filtered_nodes ) )
2018                        {
2019                            $nodes[$host]->setShowinfo( 0 );
2020                        }
2021
2022                        if( $this->isSmall() )
2023                        {
2024                            $nodes[$host]->drawSmall();
2025                        }
2026                        else if( $this->isBig() )
2027                        {
2028                            $nodes[$host]->drawBig();
2029                        }
2030                    }
2031                }
2032            }
2033        }
2034   
2035        $this->nodes    = &$nodes;
2036
2037        if ($this->output)
2038        {
2039            header( 'Content-type: image/png' );
2040            imagePNG( $image );
2041            imageDestroy( $image );
2042        }
2043    }
2044
2045    function getImagemapArea()
2046    {
2047        $clusterimage_map    = "";
2048
2049        foreach( $this->nodes as $hostname => $node )
2050        {
2051            $node_map        = $node->getImagemapArea();
2052            $clusterimage_map    .= $node_map;
2053        }
2054
2055        return $clusterimage_map;
2056    }
2057}
2058
2059class EmptyImage
2060{
2061    function draw()
2062    {
2063        $image        = imageCreateTrueColor( 1, 1 );
2064        $colorwhite    = imageColorAllocate( $image, 255, 255, 255 );
2065        imageFill( $image, 0, 0, $colorwhite );                         
2066
2067        header( 'Content-type: image/png' );
2068        imagePNG( $image );
2069        imageDestroy( $image );
2070    }
2071}
2072
2073class HostImage
2074{
2075    var $data_gather, $cluster, $host, $node, $image;
2076    var $headerstrlen;
2077
2078    function HostImage( $data_gather, $cluster, $host )
2079    {
2080        $this->data_gather     = $data_gather;
2081        $this->cluster        = $cluster;
2082        $this->host        = $host;
2083        $this->y_offset        = 0;
2084        $this->font        = 2;
2085        $this->fontspaceing    = 2;
2086        $this->headerstrlen    = array();
2087
2088        $this->fontheight    = ImageFontHeight( $this->font );
2089        $this->fontwidth    = ImageFontWidth( $this->font );
2090
2091        $dg            = &$this->data_gather;
2092        $this->node        = &$dg->getNode( $this->host );
2093        $n            = &$this->node;
2094        $this->njobs        = $n->getJobs();
2095    }
2096
2097    function drawJobs()
2098    {
2099        $dg                     = &$this->data_gather;
2100        $colorblack        = imageColorAllocate( $this->image, 0, 0, 0 );
2101
2102        for( $n = 0; $n < count( $this->njobs ); $n++ )
2103        {
2104            $jobid            = $this->njobs[$n];
2105            $jobinfo        = $dg->getJob( $jobid );
2106
2107            $xoffset        = 5;
2108            imageString( $this->image, $this->font, $xoffset, $this->y_offset, strval( $jobid ), $colorblack );
2109
2110            foreach( $this->headerstrlen as $headername => $headerlen )
2111            {
2112                if( $headername == 'nodes' )
2113                {
2114                    $attrval    = strval( count( $jobinfo['nodes'] ) );
2115                }
2116                else if( $headername == 'cpus' )
2117                {
2118                    if( !isset( $jobinfo['ppn'] ) )
2119                    {
2120                        $jobinfo['ppn'] = 1;
2121                    }
2122
2123                    $attrval    = strval( count( $jobinfo['nodes'] ) * intval( $jobinfo['ppn'] ) );
2124                }
2125                else if( $headername == 'runningtime' )
2126                {
2127                    $attrval    = makeTime( intval( $jobinfo['reported'] ) - intval( $jobinfo['start_timestamp'] ) );
2128                }
2129                else
2130                {
2131                    $attrval    = strval( $jobinfo[$headername] );
2132                }
2133
2134                imageString( $this->image, $this->font, $xoffset, $this->y_offset, $attrval, $colorblack );
2135       
2136                $xoffset    = $xoffset + ($this->fontwidth * ( $headerlen + 1 ) );
2137            }
2138           
2139            $this->newLineOffset();
2140        }
2141    }
2142
2143    function drawHeader()
2144    {
2145        $dg                     = &$this->data_gather;
2146
2147        for( $n = 0; $n < count( $this->njobs ); $n++ )
2148        {
2149            $jobid            = $this->njobs[$n];
2150            $jobinfo        = $dg->getJob( $jobid );
2151
2152            if( !isset( $this->headerstrlen['id'] ) )
2153            {
2154                $this->headerstrlen['id']    = strlen( strval( $jobid ) );
2155            }
2156            else if( strlen( strval( $jobid ) ) > $this->headerstrlen['id'] )
2157            {
2158                $this->headerstrlen['id']    = strlen( strval( $jobid ) );
2159            }
2160
2161            if( !isset( $this->headerstrlen['owner'] ) )
2162            {
2163                $this->headerstrlen['owner']    = strlen( strval( $jobinfo['owner'] ) );
2164            }
2165            else if( strlen( strval( $jobinfo['owner'] ) ) > $this->headerstrlen['owner'] )
2166            {
2167                $this->headerstrlen['owner']    = strlen( strval( $jobinfo['owner'] ) );
2168            }
2169
2170            if( !isset( $this->headerstrlen['queue'] ) )
2171            {
2172                $this->headerstrlen['queue']    = strlen( strval( $jobinfo['queue'] ) );
2173            }
2174            else if( strlen( strval( $jobinfo['queue'] ) ) > $this->headerstrlen['queue'] )
2175            {
2176                $this->headerstrlen['queue']    = strlen( strval( $jobinfo['queue'] ) );
2177            }
2178
2179            if( !isset( $jobinfo['ppn'] ) )
2180            {
2181                $jobinfo['ppn'] = 1;
2182            }
2183
2184            $cpus            = count( $jobinfo['nodes'] ) * intval( $jobinfo['ppn'] );
2185
2186            if( !isset( $this->headerstrlen['cpus'] ) )
2187            {
2188                $this->headerstrlen['cpus']    = strlen( strval( $cpus ) );
2189            }
2190            else if( strlen( strval( $cpus ) ) > $this->headerstrlen['cpus'] )
2191            {
2192                $this->headerstrlen['cpus']    = strlen( strval( $cpus ) );
2193            }
2194
2195            $nodes            = count( $jobinfo['nodes'] );
2196
2197            if( !isset( $this->headerstrlen['nodes'] ) )
2198            {
2199                $this->headerstrlen['nodes']    = strlen( strval( $nodes ) );
2200            }
2201            else if( strlen( strval( $nodes) ) > $this->headerstrlen['nodes'] )
2202            {
2203                $this->headerstrlen['nodes']    = strlen( strval( $nodes ) );
2204            }
2205
2206            $runningtime        = makeTime( intval( $jobinfo[reported] ) - intval( $jobinfo['start_timestamp'] ) );
2207
2208            if( !isset( $this->headerstrlen['runningtime'] ) )
2209            {
2210                $this->headerstrlen['runningtime']    = strlen( strval( $runningtime) );
2211            }
2212            else if( strlen( strval( $runningtime) ) > $this->headerstrlen['runningtime'] )
2213            {
2214                $this->headerstrlen['runningtime']    = strlen( strval( $runningtime) );
2215            }
2216
2217            if( !isset( $this->headerstrlen['name'] ) )
2218            {
2219                $this->headerstrlen['name']    = strlen( strval( $jobinfo['name'] ) );
2220            }
2221            else if( strlen( strval( $jobinfo['name'] ) ) > $this->headerstrlen['name'] )
2222            {
2223                $this->headerstrlen['name']    = strlen( strval( $jobinfo['name'] ) );
2224            }
2225        }
2226
2227        $xoffset    = 5;
2228
2229        foreach( $this->headerstrlen as $headername => $headerlen )
2230        {
2231            $colorgreen    = imageColorAllocate( $this->image, 0, 200, 0 );
2232
2233            if( $headerlen < strlen( $headername ) )
2234            {
2235                $this->headerstrlen[$headername]    = strlen( $headername );
2236            }
2237
2238            imageString( $this->image, $this->font, $xoffset, $this->y_offset, ucfirst( $headername ), $colorgreen );
2239
2240            $xoffset    = $xoffset + ($this->fontwidth * ( $this->headerstrlen[$headername] + 1 ) );
2241        }
2242        $this->newLineOffset();
2243    }
2244
2245    function newLineOffset()
2246    {
2247        $this->y_offset        = $this->y_offset + $this->fontheight + $this->fontspaceing;
2248    }
2249
2250    function draw()
2251    {
2252        $xlen        = 450;
2253        $ylen        = ( count( $this->njobs ) * ( $this->fontheight + $this->fontspaceing ) ) + (3 * $this->fontheight);
2254
2255        $this->image    = imageCreateTrueColor( $xlen, $ylen );
2256        $colorwhite    = imageColorAllocate( $this->image, 255, 255, 255 );
2257        imageFill( $this->image, 0, 0, $colorwhite );                         
2258
2259        $colorblue    = imageColorAllocate( $this->image, 0, 0, 255 );
2260
2261        imageString( $this->image, $this->font, 1, $this->y_offset, "Monarch Joblist - host: ".$this->host, $colorblue );
2262        $this->newLineOffset();
2263
2264        $this->drawHeader();
2265        $this->drawJobs();
2266
2267        header( 'Content-type: image/png' );
2268        imagePNG( $this->image );
2269        imageDestroy( $this->image );
2270    }
2271}
2272
2273function imageStringDown( &$image, $font, $x, $y, &$s, &$col )
2274{
2275    $fw    = imagefontwidth( $font);
2276    $fh    = imagefontheight( $font);
2277   
2278    $fontspacing = 0;
2279
2280    $fx    = $x;
2281    $fy    = $y;
2282
2283    for( $n=0; $n<strlen( $s ); $n++ )
2284    {
2285        $myc    = $s{$n};
2286
2287        imagestring( $image, $font, $fx, $fy, $myc, $col );
2288
2289        $fy    += ($fontspacing + $fh );
2290    }
2291}
2292
2293function array_rem( $val, &$arr )
2294{
2295    // Delete val from arr
2296    //
2297    $i    = array_search( $val, $arr );
2298
2299    if( $i == false ) return false;
2300
2301    $arr    = array_merge( array_slice( $arr, 0, $i ), array_slice( $arr, $i+1, count( $arr ) ) );
2302
2303    return true;
2304}
2305
2306function cmp( $a, $b ) 
2307{
2308    global $SORT_ORDER;
2309    global $skan_str;
2310    global $x_first, $y_first;
2311    global $x_present, $y_present;
2312
2313    $a_node        = $a;
2314    $b_node        = $b;
2315    $a        = $a_node->getHostname();
2316    $b        = $b_node->getHostname();
2317
2318    if( $a == $b ) return 0;
2319
2320    $a_x        = 0;
2321    $b_x        = 0;
2322    $a_y        = 0;
2323    $b_y        = 0;
2324
2325    if( $x_present && $y_present )
2326    {
2327        if( $x_first )
2328        {
2329            $n = sscanf( $a, $skan_str, $a_x, $a_y );
2330            $n = sscanf( $b, $skan_str, $b_x, $b_y );
2331        }
2332        else if( $y_first )
2333        {
2334            $n = sscanf( $a, $skan_str, $a_y, $a_x );
2335            $n = sscanf( $b, $skan_str, $b_y, $b_x );
2336        }
2337    } 
2338    else if( $x_present && !$y_present )
2339    {
2340        $n = sscanf( $a, $skan_str, $a_x );
2341        $n = sscanf( $b, $skan_str, $b_x );
2342    }
2343    else if( $y_present && !$x_present )
2344    {
2345        $n = sscanf( $a, $skan_str, $a_y );
2346        $n = sscanf( $b, $skan_str, $b_y );
2347    }
2348
2349    if ( $SORT_ORDER=="desc" )
2350    {
2351
2352        if( $x_present && $y_present )
2353        {
2354            // 1  = a < b
2355            // -1 = a > b
2356            //
2357            if ($a_x == $b_x)
2358            {
2359                if ($a_y < $b_y)
2360                {
2361                    return 1;
2362                }
2363                else if ($a_y > $b_y)
2364                {
2365                    return -1;
2366                }
2367            }
2368            else if ($a_x < $b_x)
2369            {
2370                return 1;
2371            }
2372            else if ($a_x > $b_x)
2373            {
2374                return -1;
2375            }
2376        } 
2377        else if( $x_present && !$y_present )
2378        {
2379            if ($a_x < $b_x)
2380            {
2381                return 1;
2382            }
2383            else if ($a_x > $b_x)
2384            {
2385                return -1;
2386            }
2387        }
2388        else if( $y_present && !$x_present )
2389        {
2390            if ($a_y < $b_y)
2391            {
2392                return 1;
2393            }
2394            else if ($a_y > $b_y)
2395            {
2396                return -1;
2397            }
2398        }
2399    }
2400    else if ( $SORT_ORDER == "asc" )
2401    {
2402
2403        if( $x_present && $y_present )
2404        {
2405            // 1  = a > b
2406            // -1 = a < b
2407            //
2408            if ($a_x == $b_x)
2409            {
2410                if ($a_y > $b_y)
2411                {
2412                    return 1;
2413                }
2414                else if ($a_y < $b_y)
2415                {
2416                    return -1;
2417                }
2418            }
2419            else if ($a_x > $b_x)
2420            {
2421                return 1;
2422            }
2423            else if ($a_x < $b_x)
2424            {
2425                return -1;
2426            }
2427        }
2428        else if( $x_present && !$y_present )
2429        {
2430            if ($a_x > $b_x)
2431            {
2432                return 1;
2433            }
2434            else if ($a_x < $b_x)
2435            {
2436                return -1;
2437            }
2438        }
2439        else if( $y_present && !$x_present )
2440        {
2441            if ($a_y > $b_y)
2442            {
2443                return 1;
2444            }
2445            else if ($a_y < $b_y)
2446            {
2447                return -1;
2448            }
2449        }
2450    }
2451}
2452function makeTime( $time )
2453{
2454        $days = intval( $time / 86400 );
2455        $time = ($days>0) ? $time % ($days * 86400) : $time;
2456
2457        $date_str = '';
2458        $day_str = '';
2459
2460        if( $days > 0 )
2461        {
2462            if( $days > 1 )
2463            {
2464                $day_str .= $days . ' days';
2465            }
2466            else
2467            {
2468                $day_str .= $days . ' day';
2469            }
2470        }
2471
2472        $hours = intval( $time / 3600 );
2473        $time = $hours ? $time % ($hours * 3600) : $time;
2474
2475        if( $hours > 0 )
2476        {
2477             $date_str .= $hours . ':';
2478             $date_unit = 'hours'; 
2479        }
2480
2481        $minutes = intval( $time / 60 );
2482        $seconds = $minutes ? $time % ($minutes * 60) : $time;
2483
2484        if( $minutes > 0 )
2485        {
2486            if( $minutes >= 10 )
2487            {
2488                $date_str .= $minutes . ':';
2489            }
2490            else
2491            {
2492                $date_str .= '0' . $minutes . ':';
2493            }
2494                $date_unit = (!isset($date_unit)) ? 'minutes' : $date_unit;
2495        }
2496        else
2497        {
2498            if($hours > 0 )
2499            {
2500                $date_str .= '00:';
2501                $date_unit = (!isset($date_unit)) ? 'minutes' : $date_unit;
2502            }
2503        }
2504
2505        $date_unit = (!isset($date_unit)) ? 'seconds' : $date_unit;
2506
2507        if( $seconds > 0 )
2508        {
2509            if( $seconds >= 10 )
2510            {
2511                $date_str .= $seconds . ' ' . $date_unit;
2512            }
2513            else
2514            {
2515                $date_str .= '0' . $seconds . ' ' . $date_unit;
2516            }
2517        }
2518        else if ( $hours > 0 or $minutes > 0 )
2519        {
2520            $date_str .= '00 ' . $date_unit;
2521        }
2522
2523        if( $days > 0)
2524        {
2525            if( $hours > 0 or $minutes > 0 or $seconds > 0 )
2526            {
2527                $date_str = $day_str . ' - ' . $date_str;
2528            }
2529            else
2530            {
2531                $date_str = $day_str;
2532            }
2533        }
2534        return $date_str;
2535}
2536?>
Note: See TracBrowser for help on using the repository browser.