#---------------------------------------------------------------
# ____                   _ _         ____  _
#|  _ \ ___  _   _  __ _| | |_ _   _/ ___|| |__   __ _ _ __ ___
#| |_) / _ \| | | |/ _` | | __| | | \___ \| '_ \ / _` | '__/ _ \
#|  _ < (_) | |_| | (_| | | |_| |_| |___) | | | | (_| | | |  __/
#|_| \_\___/ \__, |\__,_|_|\__|\__, |____/|_| |_|\__,_|_|  \___|
#            |___/             |___/
#
# Copyright (C) 2010 RoyaltyShare, Inc.      All Rights Reserved
#---------------------------------------------------------------
package RDAS::Throttler::Host;

use strict;

use Sys::CpuLoad;

use lib '/app/tools/rdas/lib';
use RDAS::DB::Item::ThrottlerHost;

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

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

    $self->SUPER::_init(%args);

    if ( defined $args{hostname} ) {
        return $self->_initFromHostname( $args{hostname} );
    } elsif ( $args{dbItem} ) {
        return $self->_initFromDBItem( $args{dbItem} );
    } else {
        return $self->_initFromDefaults();
    }

    return $self;
}

sub _initFromDefaults {
    my ($self) = @_;

    my $hostname = Common::RSApp::GetRealHostname();

    my ( $currentLoad, $fiveMinLoad, $fifteenMinLoad ) = Sys::CpuLoad::load();

    Log->debug("Initialize from defaults: host => $hostname");
    Log->debug("- Current load: $currentLoad");

    return $self->_initFromHashref( {
            hostname        => $hostname,
            pid             => $$,
            os              => $^O,
            load_average_1  => $currentLoad,
            load_average_5  => $fiveMinLoad,
            load_average_15 => $fifteenMinLoad,
        }
    );
}

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

    return $self->_initFromDBItem( RDAS::DB::Item::ThrottlerHost->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};

    return $self;
}

sub updateHeartbeat {
    my $self = shift;

    $self->{Heartbeat} = Common::DB::Item::kDateTimeNow;

    return $self->save();
}

sub save {
    my $self = shift;

    my $dbItem = RDAS::DB::Item::ThrottlerHost->Lookup( hostname => $self->{Hostname} )
      || RDAS::DB::Item::ThrottlerHost->Create();

    $dbItem->hostname( $self->{Hostname} );
    $dbItem->pid( $self->{PID} );
    $dbItem->heartbeat( $self->{Heartbeat} );
    $dbItem->load_average_1( $self->{LoadAverage1} );
    $dbItem->load_average_5( $self->{LoadAverage5} );
    $dbItem->load_average_15( $self->{LoadAverage15} );
    $dbItem->on_hold( $self->{OnHold} );
    $dbItem->os( $self->{OS} );

    $dbItem->save();

}

1;