reporter.cc

Go to the documentation of this file.

#include "config.h"

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

#include "asserts.h"
#include "error.h"
#include "estring.h"
#include "fs.h"
#include "rconfig.h"
#include "timer.h"
#include "logger.h"
#include "estat.h"
#include "vaulter.h"
#include "strfmt.h"
#include "archiver.h"
#include "table.h"

#include "reporter.h"

//-----------------------------------------------------------------------------

/** C'tor */
vault_stats_report::vault_stats_report()
{
        clear();
}

/** C'tor */
vault_stats_report::vault_stats_report(const vault_stats_report& a_class)
{
        clear();
        assign(a_class);
}

/** C'tor */
vault_stats_report::vault_stats_report(
        const std::string& a_message,
        const filesystem& a_class
        )
{
        clear();
        assign(a_message,a_class);
}

/** D'tor */
vault_stats_report::~vault_stats_report()
{
}

/** Clear all values */
void vault_stats_report::clear(void)
{
        m_total_blocks = 0;
        m_free_blocks = 0;
        m_total_inodes = 0;
        m_free_inodes = 0;
}

/** Assignment */
void vault_stats_report::assign(
        const vault_stats_report& a_class
        )
{
        assign(
                a_class.message(),
                a_class.time(),
                a_class.total_blocks(),
                a_class.free_blocks(),
                a_class.total_inodes(),
                a_class.free_inodes()
                );
}

/** Assignment */
void vault_stats_report::assign(
        const std::string& a_message,
        const filesystem& a_class
        )
{
        assign(
                a_message,
                current_time(),
                a_class.total_blocks(),
                a_class.free_blocks(),
                a_class.total_inodes(),
                a_class.free_inodes()
                );
}

/** Assignment */
void vault_stats_report::assign(
        const std::string& a_message,
        const std::string& a_time,
        const uint64 a_total_blocks,
        const uint64 a_free_blocks,
        const uint64 a_total_inodes,
        const uint64 a_free_inodes
        )
{
        TRY_nomem(m_message = a_message);
        m_total_blocks = a_total_blocks;
        m_free_blocks = a_free_blocks;
        m_total_inodes = a_total_inodes;
        m_free_inodes = a_free_inodes;

        TRY_nomem(m_time = a_time);
}

/** Return a string timestamp */
const std::string& vault_stats_report::time(void) const
{
        return(m_time);
}

/** Return the message */
const std::string& vault_stats_report::message(void) const
{
        return(m_message);
}

/** Return the total number of blocks in the vault */
const uint64 vault_stats_report::total_blocks(void) const
{
        return(m_total_blocks);
}

/** Return the number of free blocks in the vault */
const uint64 vault_stats_report::free_blocks(void) const
{
        return(m_free_blocks);
}

/** Return the total number of inodes in the vault */
const uint64 vault_stats_report::total_inodes(void) const
{
        return(m_total_inodes);
}

/** Return the number of free inodes in the vault */
const uint64 vault_stats_report::free_inodes(void) const
{
        return(m_free_inodes);
}

/** Assignment operator */
vault_stats_report& 
vault_stats_report::operator=(const vault_stats_report& a_class)
{
        assign(a_class);
        return(*this);
}

//-----------------------------------------------------------------------------

/** C'tor */
vault_report::vault_report()
{
        clear();
}

/** D'tor */
vault_report::~vault_report()
{
}

/** Clear all values */
void vault_report::clear(void)
{
        m_reports.clear();
}

/** Add a vault report to the list */
void vault_report::add_report(
        const vault_stats_report& a_class
        )
{
        TRY_nomem(m_reports.push_back(a_class));
}

/** Format and print the vault report to the given stream */
void vault_report::write_report(std::ostream& out)
{
        table tab, tab2;
        estring estr;
        std::vector<vault_stats_report>::const_iterator vi;
        uint64 ui64b, ui64e, ui64t;

        estr = "Vault Statistics";
        estr.align(estring::center);
        tab << estr << table_endl;

        estr = "";
        estr.fillchar('-');
        estr.align(estring::left);
        tab << estr << table_endl;

        // Header
        tab2
                << "Time"
                << " "
                << "Message"
                << " "
                << "Free Blocks"
                << " "
                << "Free Inodes"
                << " "
                << table_endl;
        
        // Separators
        estr.align(estring::left);
        estr.fillchar('-');
        estr = "";
        tab2
                << estr
                << " "
                << estr
                << " "
                << estr
                << " "
                << estr
                << table_endl;

        // Vault messages/statistics
        estr.fillchar(' ');
        for (vi = m_reports.begin(); vi != m_reports.end(); ++vi) {
                tab2
                        << vi->time()
                        << " ";

                estr.align(estring::right);
                estr = vi->message();
                tab2 << estr;

                tab2 << " ";

                estr.align(estring::center);

                estr = "  ";
                estr += percent_string(vi->free_blocks(), vi->total_blocks());
                tab2 << estr;

                tab2 << " ";

                estr = "  ";
                estr += percent_string(vi->free_inodes(), vi->total_inodes());
                tab2 << estr;

                tab2 << table_endl;
        }

        // Separators
        estr.align(estring::left);
        estr.fillchar('-');
        estr = "";
        tab2
                << " "
                << " "
                << " "
                << " "
                << estr
                << " "
                << estr
                << table_endl;
        
        // Final
        estr.align(estring::right);
        estr.fillchar(' ');
        estr = "Total Difference:";
        // estr.align(estring::center);
        // estr.fillchar(' ');
        tab2
                << " "
                << " "
                << estr
                << " ";
        
        estr.align(estring::center);
        ASSERT(m_reports.size() > 0);
        ui64b = m_reports[0].free_blocks();
        ui64e = m_reports[m_reports.size()-1].free_blocks();
        ui64t = m_reports[0].total_blocks();
        if (ui64b > ui64e) {
                estr = "-";
                estr += percent_string(ui64b - ui64e, ui64t);
        }
        else {
                estr = "+";
                estr += percent_string(ui64e - ui64b, ui64t);
        }
        tab2 << estr;

        tab2 << " ";

        ui64b = m_reports[0].free_inodes();
        ui64e = m_reports[m_reports.size()-1].free_inodes();
        ui64t = m_reports[0].total_inodes();
        if (ui64b > ui64e) {
                estr = "-";
                estr += percent_string(ui64b - ui64e, ui64t);
        }
        else {
                estr = "+";
                estr += percent_string(ui64e - ui64b, ui64t);
        }
        tab2 << estr;

        tab2 << table_endl;

        tab << tab2;

        out << tab;
}

/** Generate a synopsis report */
void vault_report::format_synopsis(table& a_table)
{
        estring estr;

        estr.align(estring::right);
        estr = "Timestamp:";
        a_table << estr << " " << config.timestamp().str() << table_endl;

        estr = "Vault Selected:";
        a_table << estr << " " << vaulter.vault() << table_endl;
}

//-----------------------------------------------------------------------------

/** C'tor */
job_path_report::job_path_report()
{
        clear();
}

/** C'tor */
job_path_report::job_path_report(const job_path_report& a_class)
{
        clear();
        assign(a_class);
}

/** C'tor */
job_path_report::job_path_report(
        const std::string a_source,
        const timer a_time,
        const uint16 a_exit_code,
        const uint16 a_signal_num,
        const std::string a_error_message
        )
{
        clear();
        assign(a_source, a_time, a_exit_code, a_signal_num, a_error_message);
}

/** D'tor */
job_path_report::~job_path_report()
{
}

/** Clear all values */
void job_path_report::clear(void)
{
        m_source.erase();
        m_time.clear();
        m_exit_code = 0;
        m_signal_num = 0;
        m_error_msg.erase();
}

/** Assignment */
void job_path_report::assign(const job_path_report& a_class)
{
        assign(
                a_class.m_source, 
                a_class.m_time,
                a_class.m_exit_code,
                a_class.m_signal_num,
                a_class.m_error_msg
                );
}

/** Assignment */
void job_path_report::assign(
        const std::string a_source,
        const timer a_time,
        const uint16 a_exit_code,
        const uint16 a_signal_num,
        const std::string a_error_message
        )
{
        TRY_nomem(m_source = a_source);
        TRY_nomem(m_error_msg = a_error_message);
        TRY_nomem(m_time = a_time);
        m_exit_code = a_exit_code;
        m_signal_num = a_signal_num;
}

/** Return true if rsync succeeded archiving this path */
const bool job_path_report::status(void) const
{
        if ((m_exit_code == 0) && (m_signal_num == 0)) {
                return(true);
        }
        return(false);
}

/** Set the path archived for this report */
void job_path_report::source(const std::string& a_class)
{
        TRY_nomem(m_source = a_class);
}

/** Return a string of the path archived */
const std::string& job_path_report::source(void) const
{
        return(m_source);
}

/** Set the timer values for this report */
void job_path_report::time(const timer& a_class)
{
        TRY_nomem(m_time = a_class);
}

/** Return the timer object for this report */
const timer& job_path_report::time(void) const
{
        return(m_time);
}

/** Set rsync's return exit code when archiving this path */
void job_path_report::exit_code(const int a_exit_code)
{
        m_exit_code = a_exit_code;
}

/** Return rsync's exit code */
const int job_path_report::exit_code(void) const
{
        return(m_exit_code);
}

/** Set rsync's signal number from archiving this path */
void job_path_report::signal_num(const int a_signal_num)
{
        m_signal_num = a_signal_num;
}

/** Return rsync's signal number */
const int job_path_report::signal_num(void) const
{
        return(m_signal_num);
}

/** Set a descriptive error message for this report */
void job_path_report::error_msg(const std::string& a_class)
{
        TRY_nomem(m_error_msg = a_class);
}

/** Return the error message */
const std::string& job_path_report::error_msg(void) const
{
        return(m_error_msg);
}

/** Assignment operator */
job_path_report& job_path_report::operator=(const job_path_report& a_class)
{
        assign(a_class);
        return(*this);
}

//-----------------------------------------------------------------------------

/** Report type tags */
const char *reportio::tags[] = {
        "[RSYNC]: ",
        "[REPORT]: ",
        0
};

/** Write a report line for output from rsync to parent on child's std::cout 
 */
void reportio::write_rsync_out(const std::string& a_str)
{
        std::cout.flush();
        std::cout << tags[rsync] << a_str << std::endl;
        std::cout.flush();
}

/** Write a report line for output from rsync to parent on child's std::cerr
 */
void reportio::write_rsync_err(const std::string& a_str)
{
        std::cerr.flush();
        std::cerr << tags[rsync] << a_str << std::endl;
        std::cerr.flush();
}

/** Generate and submit a report to the parent process on child's std::cout
 */
void reportio::write_report(
                const std::string a_source,
                const timer& a_timer,
                const int a_exit_code,
                const int a_signal_num,
                const std::string& a_error_msg
        )
{
        estring str;

        str += estring(a_source.size());
        str += " ";
        str += a_source;
        str += " ";
        str += estring(static_cast<uint64>(a_timer.start_value()));
        str += " ";
        str += estring(static_cast<uint64>(a_timer.stop_value()));
        str += " ";
        str += estring(a_exit_code);
        str += " ";
        str += estring(a_signal_num);
        str += " ";
        str += estring(a_error_msg.size());
        str += " ";
        str += a_error_msg;
        str += " ";

        std::cout.flush();
        std::cout << tags[report] << str << std::endl;
        std::cout.flush();
}

/** Parse a received report from a child process and return a job_path_report
 */
job_path_report reportio::parse(const std::string& a_str)
{
        estring es;
        job_path_report jpr;
        estring estr;
        estring::size_type idx;
        estring::size_type size;
        estring tmp;
        estring source;
        timer::value_type start_time;
        timer::value_type stop_time;
        int exit_code;
        int signal_num;
        estring error_msg;

        TRY_nomem(estr = a_str);
        idx = estr.find(tags[report]);
        if (idx == std::string::npos) {
                estring es;

                es = "Invalid job report: \"";
                es += a_str;
                es += "\"";

                throw(INTERNAL_ERROR(0,es));
        }
        
        // TODO: A lot of assumptions are being made here, put in some checking code

        estr.erase(0,idx+strlen(tags[report]));

        idx = estr.find(' ');
        tmp = estr.substr(0,idx);
        estr.erase(0,idx+1);
        size = tmp;
        source = estr.substr(0,size);
        estr.erase(0,size+1);

        idx = estr.find(' ');
        tmp = estr.substr(0,idx);
        estr.erase(0,idx+1);
        start_time = static_cast<uint64>(tmp);

        idx = estr.find(' ');
        tmp = estr.substr(0,idx);
        estr.erase(0,idx+1);
        stop_time = static_cast<uint64>(tmp);

        idx = estr.find(' ');
        tmp = estr.substr(0,idx);
        estr.erase(0,idx+1);
        exit_code = tmp;

        idx = estr.find(' ');
        tmp = estr.substr(0,idx);
        estr.erase(0,idx+1);
        signal_num = tmp;

        idx = estr.find(' ');
        tmp = estr.substr(0,idx);
        estr.erase(0,idx+1);
        size = tmp;
        error_msg = estr.substr(0,size);
        estr.erase(0,size+1);

        jpr.assign(
                source,
                timer(start_time,stop_time),
                exit_code,
                signal_num,
                error_msg
        );

        return(jpr);
}

/** Return true if the given string looks like a valid report */
bool reportio::is_report(const std::string& a_class)
{
        estring::size_type idx;

        idx = a_class.find(tags[report]);
        if (idx == std::string::npos) {
                return(false);
        }
        return(true);
}

//-----------------------------------------------------------------------------

/** C'tor */
single_job_report::single_job_report()
{
        clear();
}

/** D'tor */
single_job_report::~single_job_report()
{
}

/** Clear all values  */
void single_job_report::clear(void)
{
        m_reports.clear();
        m_id.erase();
}

/** Add a path report for this job */
void single_job_report::add_report(const job_path_report& a_class)
{
        TRY_nomem(m_reports.push_back(a_class));
}

/** Return a const vector of all path reports */
const std::vector<job_path_report>& single_job_report::reports(void) const
{
        return(m_reports);
}

/** Set a descriptive ID for this job report */
void single_job_report::id(const std::string& a_str)
{
        TRY_nomem(m_id = a_str);
}

/** Return the descriptive id for this job report */
const std::string& single_job_report::id(void) const
{
        return(m_id);
}

/** If all path reports say that rsync was successful, then return true, else
 * return false */
const bool single_job_report::status(void) const
{
        bool value = true;
        std::vector<job_path_report>::const_iterator jpri;

        for (jpri = m_reports.begin(); jpri != m_reports.end(); ++jpri) {
                if (!jpri->status())
                        value = false;
        }

        return(value);
}

//-----------------------------------------------------------------------------

/** C'tor */
jobs_report::jobs_report()
{
        clear();
}

/** D'tor */
jobs_report::~jobs_report()
{
}

/** Clear all values */
void jobs_report::clear(void)
{
        m_jobs.clear();
}

/** Add a job report to the list */
void jobs_report::add_report(const single_job_report& a_class)
{
        TRY_nomem(m_jobs.push_back(a_class));
}

/** Return a const vector of all job reports */
const std::vector<single_job_report>& jobs_report::reports(void) const
{
        return(m_jobs);
}

/** Format job reports and output to the given stream */
void jobs_report::write_report(std::ostream& a_out)
{
        std::vector<single_job_report>::const_iterator ji;
        std::vector<job_path_report>::const_iterator jpi;
        estring estr;
        estring estr2;
        estring hsep;
        estring vsep;
        estring vsep2;

        hsep.fillchar('-');
        vsep = " | ";
        vsep2 = "|";
        
        for (ji = m_jobs.begin(); ji != m_jobs.end(); ++ji) {
                table t1, t2;
                bool first_line = true;

                if (ji != m_jobs.begin())
                        a_out << std::endl;

                estr.align(estring::left);
                estr = "Job: ";
                estr += ji->id();
                t1 << estr;
                t1 << table_endl;

                t1 << hsep;
                t1 << table_endl;

                t2 << "Job" << vsep << "Path" << " " << " " 
                        << table_endl;
                t2 << "Status" << vsep << "Status" << " " << "Source" 
                        << table_endl;
                t2 << hsep << vsep << hsep << " " << hsep << table_endl;

                for (jpi = ji->reports().begin(); jpi != ji->reports().end(); ++jpi) {
                        if (jpi != ji->reports().begin())
                                t2 << table_endl;

                        if (first_line) {
                                if (ji->status())
                                        t2 << "OK";
                                else
                                        t2 << "ERROR";
                                first_line = false;
                        }
                        else {
                                t2 << " " << vsep << " " << " " << table_endl << " ";
                        }

                        t2 << table_repeat << vsep;

                        if (jpi->status())
                                t2 << "OK";
                        else
                                t2 << "ERROR";

                        t2 << " ";

                        t2 << jpi->source();

                        t2 << table_endl;

                        t2 << " " << table_repeat << vsep << " " << " ";

                        table t3, t4;

                        t3 << "+" << hsep << hsep << table_endl;
                        t3 << table_repeat << vsep2 << " ";

                        estr.align(estring::right);
                        estr2.align(estring::right);

                        estr = "Start:";
                        estr2 = jpi->time().started_at();
                        estr2 += "  ";
                        t4 << " " << estr << " " << estr2 << table_endl;

                        estr = "Finish:";
                        estr2 = jpi->time().stopped_at();
                        estr2 += "  ";
                        t4 << " " << estr << " " << estr2 << table_endl;

                        estr = "Duration:";
                        estr2 = jpi->time().duration();
                        t4 << " " << estr << " " << estr2 << table_endl;

                        t3 << t4 << table_endl;

                        estr2.align(estring::left);
                        if (!jpi->status()) {
                                table t5;

                                t3 << vsep2 << " " << " " << table_endl;
                                t3 << table_repeat << vsep2 << " ";

                                estr = "Exit Code:";
                                estr2 = estring(jpi->exit_code());
                                if (jpi->exit_code() != 0) {
                                        estr2 += " ";
                                        estr2 += rsync_estat_str.exit(jpi->exit_code());
                                }
                                t5 << " " << estr << " " << estr2 << table_endl;

                                estr = "Signal Num:";
                                estr2 = estring(jpi->signal_num());
                                if (jpi->signal_num() != 0) {
                                        estr2 += " ";
                                        estr2 += rsync_estat_str.signal(jpi->signal_num());
                                }
                                t5 << " " << estr << " " << estr2 << table_endl;

                                if (jpi->error_msg().size() > 0) {
                                        estr = "Error Msg:";
                                        estr2 = jpi->error_msg();
                                        t5 << " " << estr << " " << estr2 << table_endl;
                                }

                                t3 << t5;
                        }

                        // TODO: File statistics should go here

                        t2 << t3;
                }

                t1 << t2;

                a_out << t1;
        }
}

/** Generate a synopsis report */
void jobs_report::format_synopsis(table& a_table)
{
        estring estr, estr2;
        std::vector<single_job_report>::const_iterator sjri;
        uint16 jobs_good = 0;
        uint16 jobs_bad = 0;
        uint16 jobs_total = 0;

        estr.align(estring::right);

        for (sjri = m_jobs.begin(); sjri != m_jobs.end(); ++sjri) {
                if (sjri->status())
                        ++jobs_good;
                else
                        ++jobs_bad;
                ++jobs_total;
        }

        estr = "Successful Jobs:";
        estr2 = estring(jobs_good);
        estr2 += " out of ";
        estr2 += estring(m_jobs.size());
        estr2 += " (";
        estr2 += percent_string(jobs_good, jobs_total);
        estr2 += ")";

        a_table << estr << " " << estr2 << table_endl;
}

//-----------------------------------------------------------------------------

/** C'tor */
report_manager::report_manager()
{
        m_initialized = false;
}

/** D'tor */
report_manager::~report_manager()
{
}

/** Initialize */
void report_manager::init(void)
{
        if (!config.initialized()) {
                throw(INTERNAL_ERROR(0,"Configuration manager is not initialized"));
        }
        m_initialized = true;
}

/** Return whether or not this object has been inintialized */
const bool report_manager::initialized(void) const
{
        return(m_initialized);
}

/** Clear all values */
void report_manager::clear(void)
{
        m_total_time.clear();
        m_vault.clear();
        m_jobs.clear();
}

/** Report the overall RVM time */
void report_manager::set_total_time(const timer& a_class)
{
        if (!initialized())
                throw(INTERNAL_ERROR(0,"Report manager is not initialized"));

        m_total_time = a_class;
}

/** Return the vault reporter object */
vault_report& report_manager::vault(void)
{
        return(m_vault);
}

/** Return the jobs reporter object */
jobs_report& report_manager::jobs(void)
{
        return(m_jobs);
}

/** Print report to standard output */
void report_manager::print_report(void)
{
        estring lstr;

        if (!initialized())
                throw(INTERNAL_ERROR(0,"Report manager is not initialized"));

        lstr = "Reporter - Printing report to stdout...\n";
        logger.write(lstr);

        write_report(std::cout);

        lstr = "Reporter - Done\n";
        logger.write(lstr);
}

/** Save report to a file */
void report_manager::file_report(void)
{
        std::ofstream out;
        std::string filename;
        std::string es;
        estring lstr;
        bool done = false;
        int count = 0;

        if (!initialized())
                throw(INTERNAL_ERROR(0,"Report manager is not initialized"));
        
        while (!done) {
                TRY_nomem(filename = config.log_dir());
                TRY_nomem(filename += "/");
                TRY_nomem(filename += config.timestamp().str());
                TRY_nomem(filename += ".report");
                if (count != 0) {
                        TRY_nomem(filename += ".");
                        TRY_nomem(filename += estring(count));
                }
                if (exists(filename))
                        ++count;
                else
                        done = true;
        }
        out.open(filename.c_str());
        if (!out.is_open()) {
                TRY_nomem(es = "Could not open report file: \"");
                TRY_nomem(es += filename);
                TRY_nomem(es += "\"");
                throw(ERROR(errno,es));
        }

        lstr = "Reporter - Writing report to file...\n";
        logger.write(lstr);
        write_report(out);

        out.close();

        lstr = "Reporter - Done\n";
        logger.write(lstr);
}

/** Write report to the given stream */
void report_manager::write_report(std::ostream& a_out)
{
        estring estr;
        estring es;

        mf_write_header(a_out);

        a_out << std::endl;

        mf_write_synopsis(a_out);

        a_out << std::endl;

        m_jobs.write_report(a_out);
        
        a_out << std::endl;

        m_vault.write_report(a_out);

        a_out << std::endl;
}

/** Generate a synopsis report */
void report_manager::format_synopsis(table& a_table)
{
        estring estr;
        estring estr2;

        estr.align(estring::right);
        estr2.align(estring::right);

        estr = "Start Time:";
        estr2 = m_total_time.started_at();
        estr2 += "  ";

        a_table << estr << " " << estr2 << table_endl;

        estr = "Finish Time:";
        estr2 = m_total_time.stopped_at();
        estr2 += "  ";

        a_table << estr << " " << estr2 << table_endl;

        estr = "Duration:";
        estr2 = m_total_time.duration();

        a_table << estr << " " << estr2 << table_endl;
}

void report_manager::mf_write_header(std::ostream& a_out)
{
        table t;
        estring estr;

        estr = "Rsync Vault Manager - ";
        estr += VERSION;

        t << estr << table_endl;

        estr = "";
        estr.fillchar('=');
        t << estr;

        a_out << t;
}

void report_manager::mf_write_synopsis(std::ostream& a_out)
{
        table t;
        estring estr;

        format_synopsis(t);
        vault().format_synopsis(t);
        jobs().format_synopsis(t);

        a_out << t;
}

//-----------------------------------------------------------------------------

/** The global report manager */
report_manager reporter;

---