error_mapping.hpp

Go to the documentation of this file.

/*
 * Copyright 2025 Jinwoo Sung
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#pragma once
 
#include <boost/asio/error.hpp>
#include <boost/system/error_code.hpp>
#include <optional>
#include <string>
 
#include "unilink/base/error_codes.hpp"
#include "unilink/diagnostics/error_types.hpp"
#include "unilink/wrapper/context.hpp"
 
namespace unilink {
namespace diagnostics {
 
inline ErrorCode to_unilink_error_code(const boost::system::error_code& ec) {
  if (!ec) {
    return ErrorCode::Success;
  }
 
  // Check specific boost error codes
  if (ec == boost::asio::error::connection_refused) {
    return ErrorCode::ConnectionRefused;
  }
  if (ec == boost::asio::error::timed_out) {
    return ErrorCode::TimedOut;
  }
  if (ec == boost::asio::error::connection_reset) {
    return ErrorCode::ConnectionReset;
  }
  if (ec == boost::asio::error::connection_aborted) {
    return ErrorCode::ConnectionAborted;
  }
  if (ec == boost::asio::error::network_unreachable || ec == boost::asio::error::host_unreachable) {
    return ErrorCode::NotConnected;
  }
  if (ec == boost::asio::error::already_connected) {
    return ErrorCode::AlreadyConnected;
  }
  if (ec == boost::asio::error::address_in_use) {
    return ErrorCode::PortInUse;
  }
  if (ec == boost::asio::error::access_denied) {
    return ErrorCode::AccessDenied;
  }
 
  // Fallback to generic IoError for other network errors
  return ErrorCode::IoError;
}
 
inline bool is_retryable_tcp_connect_error(const boost::system::error_code& ec) {
  if (!ec) return false;
 
  // Connection refused is temporary (server might be starting up)
  if (ec == boost::asio::error::connection_refused) return true;
  // Timeouts are temporary network glitches
  if (ec == boost::asio::error::timed_out) return true;
  // Reset connection might be temporary
  if (ec == boost::asio::error::connection_reset) return true;
  // Unreachable might be temporary routing issue
  if (ec == boost::asio::error::network_unreachable || ec == boost::asio::error::host_unreachable) return true;
  // Resource temporarily unavailable
  if (ec == boost::asio::error::try_again) return true;
 
  // Aborted usually means stopped by user, not retryable automatically
  if (ec == boost::asio::error::operation_aborted) return false;
 
  // Default to true for unknown errors in network context to be resilient?
  // Or false? The requirement says "PR2는 보수적으로 true로 둬도 됨" (conservative to keep retrying)
  return true;
}
 
inline wrapper::ErrorContext to_error_context(const diagnostics::ErrorInfo& info,
                                              std::optional<size_t> client_id = std::nullopt) {
  ErrorCode code = ErrorCode::IoError;
 
  if (info.boost_error) {
    code = to_unilink_error_code(info.boost_error);
  } else {
    // Map category if boost error is not present
    switch (info.category) {
      case ErrorCategory::CONNECTION:
        code = ErrorCode::NotConnected;
        break;
      case ErrorCategory::CONFIGURATION:
        code = ErrorCode::InvalidConfiguration;
        break;
      case ErrorCategory::SYSTEM:
        code = ErrorCode::InternalError;
        break;
      default:
        code = ErrorCode::IoError;
        break;
    }
  }
 
  // Use the message from ErrorInfo
  return wrapper::ErrorContext(code, info.message, client_id);
}
 
}  // namespace diagnostics
}  // namespace unilink