#---------------------------------------------------------------
# ____                   _ _         ____  _
#|  _ \ ___  _   _  __ _| | |_ _   _/ ___|| |__   __ _ _ __ ___
#| |_) / _ \| | | |/ _` | | __| | | \___ \| '_ \ / _` | '__/ _ \
#|  _ < (_) | |_| | (_| | | |_| |_| |___) | | | | (_| | | |  __/
#|_| \_\___/ \__, |\__,_|_|\__|\__, |____/|_| |_|\__,_|_|  \___|
#            |___/             |___/
#
# Copyright (C) 2008 RoyaltyShare, Inc.      All Rights Reserved
#---------------------------------------------------------------
package Job::JobHost;

use strict;
use lib '/app/tools/common/lib';
use Common::XMLObject;
use Common::Assert;
use Common::Util;

use lib '/app/tools/job/lib';
use Job::DB::Item::JobHost;

# !!! Move this to the DB::Item class, so we can use the value in queries.
#use constant kStaleHeartbeatThreshold => 1800; # 30 minutes

use base 'Common::XMLObject';

sub _init {
    my ( $self, %args ) = @_;

    $self->SUPER::_init(%args);
    if ( defined $args{hostname} ) {
        return $self->_initFromHostname( $args{hostname} );
    } elsif ( ref( $args{hash} ) ) {
        return $self->_initFromHashref( $args{hash} );
    } elsif ( $args{dbItem} ) {
        return $self->_initFromDBItem( $args{dbItem} );
    } else {
        return $self->_initFromDefaults();
    }

    return $self;
}

sub _initFromDefaults {
    my ($self) = @_;
    return $self->_initFromHashref( {} );
}

sub _initFromHostname {
    my ( $self, $id ) = @_;
    assert($id);

    return $self->_initFromDBItem( Job::DB::Item::JobHost->Lookup( hostname => $id ) );
}

sub _initFromDBItem {
    my ( $self, $dbItem ) = @_;

    $self->{_inDB} = 1;

    return $self->_initFromHashref( {
            hostname        => $dbItem->hostname,
            pid             => $dbItem->pid,
            heartbeat       => $dbItem->heartbeat,
            load_average_1  => $dbItem->load_average_1,
            load_average_5  => $dbItem->load_average_5,
            load_average_15 => $dbItem->load_average_15,
            on_hold         => $dbItem->on_hold,
            os              => $dbItem->os,
        }
    );
}

sub _initFromHashref {
    my ( $self, $hashref ) = @_;

    $self->{Hostname} = $hashref->{hostname};

    $self->{PID}           = $hashref->{pid};
    $self->{Heartbeat}     = $hashref->{heartbeat};
    $self->{LoadAverage1}  = $hashref->{load_average_1};
    $self->{LoadAverage5}  = $hashref->{load_average_5};
    $self->{LoadAverage15} = $hashref->{load_average_15};
    $self->{OnHold}        = $hashref->{on_hold};
    $self->{OS}            = $hashref->{os};

    # If the heartbeat seems stale, set a flag.
    #
    if ( $self->{Heartbeat} ) {
        my $heartBeatSeconds = Common::Util::dateTimeToSeconds( $self->{Heartbeat} );
        my $now              = time();
        if ( $now - $heartBeatSeconds > Job::DB::Item::JobHost::kStaleHeartbeatThreshold ) {
            $self->{HeartbeatStale} = 1;
        }
    }
    return $self;
}

1;