ExternalErrorHandler.hpp

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2016-2024 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2024 TotalEnergies
 * Copyright (c) 2018-2024 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2023-2024 Chevron
 * Copyright (c) 2019-     GEOS/GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */
 
#ifndef LOGGER_EXTERNALERRORHANDLER_HPP
#define LOGGER_EXTERNALERRORHANDLER_HPP
 
#include "ErrorHandling.hpp"
 
#include <functional>
#include <string_view>
#include <string>
#include <memory>
 
namespace geos
{
 
class OutputStreamDeviation
{
public:
 
  using PosixId = int;
 
  using LineHandlingFunctor = std::function< void (std::string_view, std::string_view) >;
 
  OutputStreamDeviation( PosixId fileNo );
 
  ~OutputStreamDeviation();
 
  void flush( LineHandlingFunctor const & lineProcessingFunctor, std::string_view detectionLocation );
 
private:
  struct Pipe
  {
    PosixId fileDescriptorsArray[2];
 
    void create();
 
    PosixId & readEnd()
    { return fileDescriptorsArray[0]; }
 
    PosixId & writeEnd()
    { return fileDescriptorsArray[1]; }
 
    bool setDescriptorInheritanceMode( bool inherit );
 
    bool redirectWriteEnd( int targetFd );
 
    void closePipe();
  };
 
  static constexpr PosixId m_disabledPipeEnd = -1;
 
  static constexpr PosixId m_errorResult = -1;
 
  PosixId m_redirectedStream;
 
  PosixId m_originalStreamTarget;
 
  Pipe m_deviationPipe;
 
  std::string m_unprocessedData;
 
  static bool setPipeEndBlockingMode( PosixId pipeEnd, bool nonBlocking );
 
  static int duplicateDescriptor( int pipeEnd );
 
  void prepareStreamingBuffer();
 
  static void closePipeEnd( PosixId & pipeEnd );
 
  static string getLastPosixErrorString();
};
 
class ExternalErrorHandler
{
public:
 
  using ErrorHandlingFunctor = OutputStreamDeviation::LineHandlingFunctor;
 
  static ExternalErrorHandler & instance();
 
  ~ExternalErrorHandler();
 
  void setErrorHandling( ErrorHandlingFunctor && errorHandlingFunctor )
  { m_processErrorFunctor = errorHandlingFunctor; }
 
  void enableStderrPipeDeviation( bool enable );
 
  void flush( std::string_view detectionLocation );
 
  static void defaultErrorHandling( std::string_view errorMsg, std::string_view detectionLocation );
 
private:
  std::unique_ptr< OutputStreamDeviation > m_stderrDeviation;
 
  ErrorHandlingFunctor m_processErrorFunctor;
 
  ExternalErrorHandler();
};
 
} /* namespace geos */
 
#endif