SbeLogDecoder.cpp

Go to the documentation of this file.

/*
 * Copyright Onix Solutions Limited [OnixS]. All rights reserved.
 *
 * This software owned by Onix Solutions Limited [OnixS] and is protected by copyright law
 * and international copyright treaties.
 *
 * Access to and use of the software is governed by the terms of the applicable ONIXS Software
 * Services Agreement (the Agreement) and Customer end user license agreements granting
 * a non-assignable, non-transferable and non-exclusive license to use the software
 * for it's own data processing purposes under the terms defined in the Agreement.
 *
 * Except as otherwise granted within the terms of the Agreement, copying or reproduction of any part
 * of this source code or associated reference material to any other location for further reproduction
 * or redistribution, and any amendments to this copyright notice, are expressly prohibited.
 *
 * Any reproduction or redistribution for sale or hiring of the Software not in accordance with
 * the terms of the Agreement is a violation of copyright law.
 */
#include <OnixS/ICE/BOE/Messaging.h>
#include <OnixS/ICE/BOE/utils/FileSystem.h>
#include <OnixS/ICE/BOE/encoding/Base64Encoding.h>
 
#include <string>
#include <iostream>
#include <cstdio>
#include <fstream>
 
using namespace ONIXS_ICEBOE_NAMESPACE;
using namespace ONIXS_ICEBOE_MESSAGING_NAMESPACE;
using namespace ONIXS_ICEBOE_NAMESPACE::Encoding;
 
#include <Common/Options.h>
 
namespace
{
    struct MessagePrinter
    {
        MessagePrinter(std::ofstream& outFile, StrRef prefix)
            : outFile_(outFile)
            , prefix_(prefix)
        {}
 
        template <typename MessageType>
        void operator()(const MessageType& msg) const
        {
            outFile_ << prefix_ << msg << std::endl << std::endl;
 
            std::cout << prefix_ << msg << std::endl << std::endl;
        }
 
        std::ofstream& outFile_;
        const StrRef prefix_;
    };
 
    std::string getOutputFileName(const std::string& entryName)
    {
        const char * const DecodedSummaryFileExtension = ".txt";
        return entryName.substr(0, entryName.find_last_of(".")) + DecodedSummaryFileExtension;
    }
 
    size_t decodeSbeLogFile(const std::string& summaryFileName)
    {
        const std::string outputFileName = getOutputFileName(summaryFileName);
        std::ofstream decoded(outputFileName.c_str());
 
        if (!decoded)
            throw std::runtime_error("Cannot create file: '" + outputFileName + "'");
 
        std::ifstream file(summaryFileName.c_str());
 
        if (!file)
            throw std::runtime_error("Cannot open " + summaryFileName + " log file.");
 
        const size_t LogLinePrefixSize = 32;
 
        std::string line;
        ByteArray buffer;
        size_t messageCounter = 0;
 
        while (getline(file, line))
        {
            try
            {
                const StrRef Prefix(line.data(), LogLinePrefixSize);
                const StrRef Base64SbeMessage(line.data() + LogLinePrefixSize, line.size() - LogLinePrefixSize);
 
                Base64Encoding::decode(buffer, Base64SbeMessage);
 
                if (buffer.empty())
                    throw std::runtime_error("Cannot decode an empty message");
 
                const auto message = NetworkMessage(&buffer[0], static_cast<MessageSize>(buffer.size())).message();
 
                assert(message.valid());
 
                if (!processTypified(message, MessagePrinter(decoded, Prefix)))
                    throw std::runtime_error("Unknown message type");
 
                ++messageCounter;
            }
            catch (...)
            {
                std::cerr << "Cannot decode '" << line << "'" << std::endl;
                throw;
            }
        }
 
        return messageCounter;
    }
 
    void gatherFiles(std::vector<std::string>& gatheredFiles, const std::string& root)
    {
        if(Filesystem::isDirectory(root))
            Filesystem::gatherFiles(&gatheredFiles, root, ".summary");
        else
            gatheredFiles.push_back(root);
    }
 
    class FileDecoder
    {
    public:
        FileDecoder()
            : messagesCount_(0)
            , filesCount_(0)
        {
        }
 
        void operator()(const std::string& name)
        {
            messagesCount_ += decodeSbeLogFile(name);
            ++filesCount_;
        }
 
        size_t messagesCount() const
        {
            return messagesCount_;
        }
 
        size_t filesCount() const
        {
             return filesCount_;
        }
 
    private:
        size_t messagesCount_;
        size_t filesCount_;
    };
}
 
int main(int argc, char* argv[])
{
    // `--help` to show options.
    const Samples::AppConfiguration<Samples::InputLogFileConfiguration> cfg{"SbeLogDecoder", argc, argv};
 
    const auto location = cfg.location();
 
    if(!Filesystem::exist(location))
    {
        std::cerr << "'" + location + "'" + " does not exist.";
        return 1;
    }
 
    std::vector<std::string> inputFiles;
    gatherFiles(inputFiles, location);
 
    const FileDecoder decoder =
        std::for_each(inputFiles.begin(), inputFiles.end(), FileDecoder());
 
    std::clog << decoder.messagesCount() << " messages in " << decoder.filesCount() << " file(s) are decoded." << std::endl << std::endl;
 
    return 0;
}