Exception.cpp

Go to the documentation of this file.

/*
* This file is part of ArmarX.
*
* Copyright (C) 2011-2016, High Performance Humanoid Technologies (H2T), Karlsruhe Institute of Technology (KIT), all rights reserved.
*
* ArmarX is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* ArmarX 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    ArmarXCore::core
* @author     Jan Issac (jan dot issac at gmx dot de)
* @author     Kai Welke (welke at kit dot edu)
* @date       2011
* @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
*             GNU General Public License
*/
 
#include "Exception.h"
#include <execinfo.h>
#include <cxxabi.h>
#include <dlfcn.h>
 
#include <cstdio>
#include <cstdlib>
#include <sstream>
 
#include <IceUtil/Exception.h>
#include <ArmarXCore/core/logging/Logging.h>
#include <Ice/LocalException.h>
#include <ArmarXCore/core/system/FactoryCollectionBase.h>
#include <ArmarXCore/util/CPPUtility/trace.h>
 
 
namespace armarx
{
    LocalException::LocalException() :
        reason(""),
        backtrace(""),
        output_buffer("")
    {
        backtrace = std::runtime_error(generateBacktrace());
        setReason("");
    }
 
    LocalException::LocalException(const LocalException& e) noexcept:
        reason(e.reason), backtrace(e.backtrace), output_buffer("")
    {
    }
 
    void LocalException::setReason(const std::string& r)
    {
        this->reason = std::runtime_error(r);
    }
 
    std::string LocalException::getReason() const
    {
        return reason.what();
    }
 
    const char* LocalException::what() const noexcept
    {
        // TODO: generateOutputString is not noexcept and changes the state of the exception
        output_buffer = std::runtime_error(generateOutputString());
 
        return output_buffer.what();
    }
 
    std::string LocalException::generateBacktrace()
    {
        int skip = 3;
        void* callstack[128];
        const int nMaxFrames = sizeof(callstack) / sizeof(callstack[0]);
        char buf[1024];
 
        int nFrames = ::backtrace(callstack, nMaxFrames);
        char** symbols = backtrace_symbols(callstack, nFrames);
 
        std::ostringstream trace_buf;
 
        for (int i = skip; i < nFrames; i++)
        {
            Dl_info info;
 
            if (dladdr(callstack[i], &info) && info.dli_sname)
            {
                char* demangled = nullptr;
                int status = -1;
 
                if (info.dli_sname[0] == '_')
                {
                    demangled = abi::__cxa_demangle(info.dli_sname, nullptr, nullptr, &status);
                }
 
                snprintf(buf, sizeof(buf), "%-3d %*p %s + %zd\n",
                         i - skip + 1, int(2 + sizeof(void*) * 2), callstack[i],
                         status == 0 ? demangled :
                         info.dli_sname == nullptr ? symbols[i] : info.dli_sname,
                         (char*)callstack[i] - (char*)info.dli_saddr);
                free(demangled);
            }
            else
            {
                snprintf(buf, sizeof(buf), "%-3d %*p %s\n",
                         i - skip + 1, int(2 + sizeof(void*) * 2), callstack[i], symbols[i]);
            }
 
            trace_buf << buf;
        }
 
        free(symbols);
 
        if (nFrames == nMaxFrames)
        {
            trace_buf << "[truncated]\n";
        }
 
        return trace_buf.str();
    }
 
    std::string LocalException::generateOutputString() const
    {
        // TODO: this is not noexcept
        std::stringstream what_buf;
 
        what_buf << std::endl;
        what_buf << "Reason: " << ((strlen(reason.what()) == 0) ? "undefined" : reason.what()) << std::endl;
        what_buf << "Backtrace: " << std::endl;
        what_buf << backtrace.what() << std::endl;
 
        return what_buf.str();
    }
 
    void handleExceptions()
    {
        *((ARMARX_LOG_S)  .setBacktrace(false)) << armarx::MessageTypeT::ERROR << GetHandledExceptionString();
        detail::Trace::ClearExceptionBacktrace();
    }
 
    std::string GetHandledExceptionString()
    {
        std:: stringstream result;
 
        try
        {
            throw;
        }
        catch (const UserException& userException)
        {
            // Handle marshallable user exceptions
            result
                    << "Caught userException: " << userException.what() << "\n"
                    << "\tReason: " << userException.reason << "\n"
                    << "\tStacktrace: \n" << userException.ice_stackTrace();
 
        }
 
 
 
        catch (const LocalException& exception)
        {
            // Handle local (run-time) exceptions
            result
                    << "Caught " << exception.name() << ":\n" << exception.what()
                    ;
        }
 
        catch (const Ice::NoValueFactoryException& e)
        {
            std::stringstream availableFactories;
 
            for (const auto& elem : FactoryCollectionBase::GetPreregistratedFactories())
            {
                ObjectFactoryMap objFacMap = elem->getFactories();
                ObjectFactoryMap::iterator it = objFacMap.begin();
 
                for (; it != objFacMap.end(); it++)
                {
                    availableFactories << "\t" << it->first;
                    availableFactories << "\n";
                }
            }
 
            auto typePart = e.type.substr(e.type.find_last_of(':') + 1);
 
            result
                    << "Caught NoObjectFactoryException:\n " << e.what()
                    << "\n\nPossible reasons:\n"
                    << "\t- You did not link the library where the object factory is declared\n"
                    << "\t- You did not include the header of the object factory\n\n"
                    << "\tThese object factories are usually located in header files called XYZObjectFactories.h. This header file needs to be included into your library."
                    << "Additionally, also the library needs to be included. To find these file you can try the following command (linux):\n"
                    << "\tgrep -r \"" << typePart << "\" ~/armarx/ --include \"*Factor*\"\n"
                    << "\t Include that header file and find out to which libray this header belongs (usually the CMakeLists.txt next to it) and link this lib to your library."
                    << "\n\nAvailable factories: \n" << availableFactories.str()
                    //                   << "\nBacktrace: " << exception.ice_stackTrace()
                    ;
        }
        catch (const Ice::UnexpectedObjectException& e)
        {
            std::stringstream availableFactories;
 
            for (const auto& elem : FactoryCollectionBase::GetPreregistratedFactories())
            {
                ObjectFactoryMap objFacMap = elem->getFactories();
                ObjectFactoryMap::iterator it = objFacMap.begin();
 
                for (; it != objFacMap.end(); it++)
                {
                    availableFactories << "\t" << it->first;
                    availableFactories << "\n";
                }
            }
 
            auto typePart = e.expectedType.substr(e.expectedType.find_last_of(':') + 1);
 
            result
                    << "Caught UnexpectedObjectException:\n " << e.what()
                    << "\n\nPossible reasons:\n"
                    << "\t- You did not link the library where the object factory is declared\n"
                    << "\t- You did not include the header of the object factory\n\n"
                    << "\tThese object factories are usually located in header files called XYZObjectFactories.h. This header file needs to be included into your library."
                    << "Additionally, also the library needs to be included. To find these file you can try the following command (linux):\n"
                    << "\tgrep -r \"" << typePart << "\" ~/armarx/ --include \"*Factor*\"\n"
                    << "\t Include that header file and find out to which libray this header belongs (usually the CMakeLists.txt next to it) and link this lib to your library."
                    << "\n\nAvailable factories: \n" << availableFactories.str()
                    //                   << "\nBacktrace: " << exception.ice_stackTrace()
                    ;
        }
 
        catch (const Ice::OperationNotExistException& e)
        {
            result
                    << "\033[1mCaught OperationNotExistException:\n " << e.what()
                    << "\n\nPossible reasons:\n"
                    << "\t- You are using a topic instead of offering a topic (usingTopic(name): receive data, offeringTopic(name): provide data) \n"
                    <<  LogSender::GetColorCodeString(LogSender::eReset);
        }
 
        catch (const IceUtil::Exception& exception)
        {
 
            result
                    << "Caught IceUtil::Exception:\n " << exception.what()
                    << "\nBacktrace: " << exception.ice_stackTrace()
                    ;
        }
        catch (const std::exception& exception)
        {
 
            result
                    << "Caught std::exception:\n" << exception.what()
                    ;
        }
        catch (...)
        {
            result
                    << "Caught unknown exception!"
                    ;
        }
        result << "\nTrace created by calling ARMARX_TRACE:\n";
        detail::Trace::PrintExceptionBacktrace(result, ">>> ");
        return result.str();
    }
}