ercole-agent

#!/usr/bin/perl

# Copyright (c) 2022 Sorint.lab S.p.A.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

package main;

use strict;
use warnings;
use diagnostics;

use lib "./lib/JSON";
use lib "./lib/HTTP";

use lib "./lib/URI"; # needed only by Solaris

use PP;
use lib "./config";
use lib "./marshal";
use config;
use common;
use host;
use cluster_membership_status;
use filesystems;
use oratab;
use database;
use tablespaces;
use schemas;
use listpdb;
use feature_usage_stats;
use licenses;
use patches;
use addms;
use segmentadvisors;
use psu;
use backup;
use grant_dba;
use size_pdb;
use charset_pdb;
use partitioning;
use LWP;
use MIME::Base64;
use lib "./logger";
use logger;

my $version = "ERCOLE_VERSION";
my $hostDataSchemaVersion = 1;


sub main {
    my %configuration = config::ReadConfig();
    logger::setLogDirectory($configuration{'LogDirectory'});
    logger::printLn("########### ercole-agent start ###########");

    while (1) {
        buildData(%configuration);
        sleep(3600 * $configuration{'frequency'});
    }
}


sub buildData {
    my %configuration = @_;
    my $out = fetcher("host", "", "X");
    my %info = marshal::Host($out);
    my %clusterMembershipStatus = marshal::ClusterMembershipStatus($out);
    my %db;

    $out = fetcher("filesystem", "", "X");
    my @filesystems = marshal::Filesystems($out);


    $out = fetcher("oratab", $configuration{'oratab'}, "X");
    my @dbs = marshal::Oratab($out);

    $out = fetcher("running-databases");
    my @runningDBs = marshal::RunningDatabases($out);

    my @runningUnlistedDatabases = ();

    foreach my $runningDB (@runningDBs) {
        my $found = 0;
        foreach my $db (@dbs) {
            my %dbEntry = %$db;
            if ($dbEntry{"dbName"} eq $runningDB) {
                $found = 1;
                last if 1;
            }
        }
        if ($found == 0) {
            push (@runningUnlistedDatabases, $runningDB);
        }
    }
    $db{"unlistedRunningDatabases"} = \@runningUnlistedDatabases;

    my @databases;

    foreach my $db (@dbs){
        my %dbEntry = %$db;
        my $dbStatus = fetchDbStatus($dbEntry{"dbName"}, $dbEntry{"oracleHome"});

        if ($dbStatus =~ m/READ WRITE/ || $dbStatus =~ m/READ ONLY/) {
            my %database;
            my $outVersion = fetcher("dbversion", $dbEntry{"dbName"}, $dbEntry{"oracleHome"});
            my ($dbVersion, $b, $c, $d) = split /\./, $outVersion;

            $out = fetcher("db", $dbEntry{"dbName"}, $dbEntry{"oracleHome"}, $configuration{'AWR'}, $dbVersion);
            %database = marshal::Database($out);


            if ($dbVersion > 11 || ($dbVersion == 11 && $b >= 2)) {
                my $out = marshal::trim(fetcher("checkpdb", $dbEntry{"dbName"}, $dbEntry{"oracleHome"}));
                $database{'isCDB'} = marshal::parseBool($out);

                if ($out eq "TRUE") {
                    $out = fetcher("listpdb", $dbEntry{"dbName"}, $dbEntry{"oracleHome"});
                    my @pdbs = marshal::ListPDBs($out);

                    my $totalSegmentsSize = 0;
                    my $totalDatafileSize = 0; 
                    my $totalAllocable = 0;

                    for (my $i = 0; $i<scalar(@pdbs); $i++) {

                        if ($pdbs[$i]{"status"} eq "MOUNTED"){
                            $pdbs[$i]{"tablespaces"} = [];
                            $pdbs[$i]{"schemas"} = [];
                            $pdbs[$i]{"segmentAdvisors"} = [];
                            $pdbs[$i]{"grantDba"} = [];

                            next;
                        }

                        $out = fetcher("size_pdb", $dbEntry{"dbName"}, $dbEntry{"oracleHome"}, $pdbs[$i]{"name"});
                        my ($segmentsSize, $datafileSize, $allocable) = marshal::Sizepdb($out);
                        $pdbs[$i]{"segmentsSize"} = $segmentsSize;
                        $pdbs[$i]{"datafileSize"} = $datafileSize;
                        $pdbs[$i]{"allocable"} = $allocable;
                        $totalSegmentsSize = $totalSegmentsSize + $segmentsSize;
                        $totalDatafileSize = $totalDatafileSize + $datafileSize;
                        $totalAllocable = $totalAllocable + $allocable;

                        $out = fetcher("charset_pdb", $dbEntry{"dbName"}, $dbEntry{"oracleHome"}, $pdbs[$i]{"name"});
                        $pdbs[$i]{"charset"} = marshal::Charsetpdb($out);
                        
                        $out = fetcher("tablespace_pdb", $dbEntry{"dbName"}, $dbEntry{"oracleHome"}, $pdbs[$i]{"name"});
                        $pdbs[$i]{"tablespaces"} = marshal::Tablespaces($out);

                        $out = fetcher("schema_pdb", $dbEntry{"dbName"}, $dbEntry{"oracleHome"}, $pdbs[$i]{"name"});
                        $pdbs[$i]{"schemas"} = marshal::Schemas($out);

                        $out = fetcher("segmentadvisor_pdb", $dbEntry{"dbName"}, $dbEntry{"oracleHome"}, $pdbs[$i]{"name"});
                        $pdbs[$i]{"segmentAdvisors"} = marshal::SegmentAdvisor($out);

                        $out = fetcher("grant_dba", $dbEntry{"dbName"}, $dbEntry{"oracleHome"});
                        $database{'grantDba'} = marshal::GrantDba($out);

                        $out = fetcher("partitioning_pdb", $dbEntry{"dbName"}, $dbEntry{"oracleHome"}, $pdbs[$i]{"name"});
                        $database{'partitionings'} = marshal::Partitioning($out);
                    }

                    $database{'pdbs'} = \@pdbs;

                    $database{'segmentsSize'} = $totalSegmentsSize;
                    $database{'datafileSize'} = $totalDatafileSize;
                    $database{'allocable'} = $totalAllocable;
                }

            } else {
                $db{'isCDB'} = marshal::parseBool("FALSE");
            }

            if ($configuration{'forcestats'} eq "true") {
                fetcher("stats", $dbEntry{"dbName"}, $dbEntry{"oracleHome"});
            }

            $out = fetcher("tablespace", $dbEntry{"dbName"}, $dbEntry{"oracleHome"});
            $database{'tablespaces'} = marshal::Tablespaces($out);

            $out = fetcher("schema", $dbEntry{"dbName"}, $dbEntry{"oracleHome"});
            $database{'schemas'} = marshal::Schemas($out);

            $out = fetcher("patch", $dbEntry{"dbName"}, $dbVersion, $dbEntry{"oracleHome"});
            $database{'patches'} = marshal::Patches($out);

            $out = fetcher("opt", $dbEntry{"dbName"}, $dbVersion, $dbEntry{"oracleHome"});
            $database{'featureUsageStats'} = marshal::FeatureUsageStats($out);

            $out = fetcher("license",$dbEntry{"dbName"}, $dbVersion, $info{'hardwareAbstractionTechnology'}, $dbEntry{"oracleHome"});
            $database{'licenses'} = marshal::Licenses($out);

            $out = fetcher("addm", $dbEntry{"dbName"}, $dbEntry{"oracleHome"});
            if ($out =~ m/Diagnostic Package License is needed for using this feature./) {
                logger::printLn("Detected Diagnostic Package License is needed for using this feature error. Ignored!");
                $database{'addms'} = ();
            } else {
                $database{'addms'} = marshal::Addms($out);
            }

            $out = fetcher("segmentadvisor", $dbEntry{"dbName"}, $dbEntry{"oracleHome"});
            $database{'segmentAdvisors'} = marshal::SegmentAdvisor($out);

            $out = fetcher("psu", $dbEntry{"dbName"}, $dbVersion, $dbEntry{"oracleHome"});
            $database{'psus'} = marshal::PSU($out);

            $out = fetcher("backup", $dbEntry{"dbName"}, $dbEntry{"oracleHome"});
            if ($out =~ m/unable to extend temp segment/) {
                logger::printLn("Detected unable to extend temp segment error. Ignored!");
                $database{'backups'}=[];
            } else {
                $database{'backups'} = marshal::Backups($out);
            }

            $out = fetcher("grant_dba", $dbEntry{"dbName"}, $dbEntry{"oracleHome"});
            $database{'grantDba'} = marshal::GrantDba($out);

            $out = fetcher("partitioning", $dbEntry{"dbName"}, $dbEntry{"oracleHome"});
            $database{'partitionings'} = marshal::Partitioning($out);

            push (@databases, {%database});

        } elsif ($dbStatus =~ m/MOUNTED/ || $dbStatus =~ m/READ ONLY WITH APPLY/) {
            $out = fetcher("dbmounted", $dbEntry{"dbName"}, $dbEntry{"oracleHome"});
            my %database = marshal::Database($out);
            $database{'licenses'} = getLicensesMountedDb( $database{'version'}, $info{'cpuCores'} );

            push (@databases, {%database});
        }
    }

    my %hostData;

    $db{"databases"} = \@databases;
    my %oracle;
    $oracle{"database"} = \%db;

    my %features;
    $features{'oracle'} = \%oracle;

    $hostData{'hostname'} = $info{'hostname'};

    if ($configuration{'hostname'} ne "default") {
        $hostData{'hostname'} = $configuration{'hostname'};
    }
    $hostData{'location'} = $configuration{'location'};
    $hostData{'environment'} = $configuration{'envtype'};
    $hostData{'period'} = $configuration{'frequency'} + 0;
    $hostData{'tags'}=[];
    $hostData{'agentVersion'} = $version;
    $hostData{'schemaVersion'} = $hostDataSchemaVersion;
    $hostData{'info'} = \%info;
    $hostData{'clusterMembershipStatus'} = \%clusterMembershipStatus;
    $hostData{'features'} = \%features;
    $hostData{'filesystems'} = \@filesystems;

    sendData(\%hostData, \%configuration);
}


sub sendData {
    no warnings 'uninitialized';
    my ($d, $c) = @_;

    my %data = %$d;
    my %configuration = %$c;

    logger::printLn("Sending data...");

    my $b = JSON::PP::encode_json(\%data);

    logger::printLn("Data:\n");
    if ($configuration{'PrettyPrintHostdata'} eq 'true') {
        my $json = JSON::PP->new->pretty(["enable"]);
        print $json->encode(\%data), "\n";
    } else {
        logger::printLn($b . "\n");
    }

    use Sys::Hostname;
    my $host = hostname;
    my $filename = "/tmp/hostdata_${host}.json";
    open(my $fh, '>', $filename) or die "Could not open file '$filename' $!";
    print $fh $b;
    close $fh;

    my $url = "$configuration{'serverurl'}/hosts";

    if ($configuration{'UseCurl'} eq 'true') {
        logger::printLn("Sending data with curl");

        $b =~ s/'/_/g ;

        my $command = "curl \\
            -H 'Content-Type: application/json' \\
            -u '$configuration{'serverusr'}':'$configuration{'serverpsw'}' \\
            -d '$b' \\
            -w 'StatusCode: %{http_code}' \\
            $url";

        if ($configuration{'EnableServerValidation'} eq "false"){
            $command = $command . " --insecure";
        }

        my $out = `$command  2>&1`;

        logger::printLn("Response output: " . $out);

    } else {

        # use lib "./lib/URI";
        my $client = LWP::UserAgent->new;

        # Disable certificate validation if enableServerValidation is false
        # if ($configuration{'EnableServerValidation'} eq "false"){
        # 	$client->ssl_opts(verify_hostname => 0);
        # }

        my $auth = $configuration{'serverusr'}.":".$configuration{'serverpsw'};
        my $authEnc = encode_base64($auth);

        my $headers = HTTP::Headers->new;
        $headers->header('Content-Type' => 'application/json');
        $headers->header('Authorization' => 'Basic '.$authEnc);

        my $req = HTTP::Request->new( 'POST', $url, $headers, $b);

        my $response = $client->request( $req );

        my $sendResult = "FAILED";

        if ($response->is_success) {
            logger::printLn("Response status: ". $response->status_line. "\n");
            logger::printLn();
            if ($response->status_line eq '200 OK') {
                $sendResult = "SUCCESS";
            }
        } else {
            logger::printLn("Error sending data: ". $response->status_line . "\n");
        }

        logger::printLn("Sending result: ".$sendResult);
    }
}


sub fetcher {
    no warnings 'uninitialized';
    my ($fetcherName, $param1, $param2, $param3, $param4) = @_;

    logger::printLn("Fetching ".$fetcherName." ".$param1." ".$param2." ".$param3." ".$param4);
    my $baseDir = config::getBaseDir();

    my $cmd = $baseDir."/fetch/$^O/".$fetcherName;

    my $out = `$cmd $param1 $param2 $param3 $param4 2>&1` ;

    if ($? == -1) {
        logger::printLn("failed to execute $fetcherName: $!");
    }

    return $out;
}


sub fetchDbStatus {
    no warnings 'uninitialized';
    my ($sid, $oracleHome) = @_;
    logger::printLn("Fetching db status ".$sid . " " . $oracleHome);
    my $baseDir = config::getBaseDir();

    my $cmd = $baseDir."/fetch/$^O/dbstatus";
    my $out = qx/$cmd $sid $oracleHome/ or die "UNREACHABLE";

    return $out;
}


sub getLicensesMountedDb {
    my $version = shift;

    my $coreFactor  = 1;
    my $cpuCores    = shift;
    my $numLicenses = $coreFactor * $cpuCores;

    my %license;

    $version = uc $version;

    my $dbEdition = "";
    if ( $version =~ /ENTERPRISE/ ) {
        $dbEdition = "ENT";
    }
    elsif ( $version =~ /EXTREME/ ) {
        $dbEdition = "EXE";
    }
    elsif ( $version =~ /EXPRESS/ ) {
        $dbEdition = "XE";
    }
    else {
        $dbEdition = "STD";
    }

    $license{'name'}  = "Oracle " . $dbEdition;
    $license{'count'} = $numLicenses;

    my @licenses;
    push( @licenses, {%license} );

    return \@licenses;
}


main();