absl::Status ↔ exception 변환 패턴

1
// 회피 — 함수마다 변환
2
std::string ReadFile(const std::string& path) {
3
    try {
4
        return std::filesystem::read_file(path);
5
    } catch (const std::filesystem::filesystem_error& e) {
6
        throw std::runtime_error(e.what());
7
    }
8
}
9

10
absl::StatusOr<std::string> Process() {
11
    try {
12
        return ReadFile("...");
13
    } catch (...) {
14
        return absl::InternalError("...");
15
    }
16
}
17

18
// Good — 한 경계에서만
19
absl::StatusOr<std::string> ReadFileSafe(const std::string& path) {
20
    try {
21
        return std::filesystem::read_file(path);
22
    } catch (const std::filesystem::filesystem_error& e) {
23
        return absl::Status(ToStatusCode(e.code()), e.what());
24
    }
25
}
26

27
// 그 이후로는 Status 흐름
28
absl::StatusOr<std::string> Process() {
29
    return ReadFileSafe("...");
30
}

1
absl::Status ToStatus(const std::exception& e) {
2
    // 가장 안전한 fallback
3
    return absl::InternalError(e.what());
4
}
5

6
absl::Status ToStatus(const std::system_error& e) {
7
    return absl::Status(ToStatusCode(e.code()), e.what());
8
}
9

10
absl::Status ToStatus(const std::filesystem::filesystem_error& e) {
11
    return absl::Status(ToStatusCode(e.code()), e.what());
12
}
13

14
absl::Status ToStatus(const std::bad_alloc&) {
15
    return absl::ResourceExhaustedError("out of memory");
16
}
17

18
absl::Status ToStatus(const std::out_of_range& e) {
19
    return absl::OutOfRangeError(e.what());
20
}
21

22
absl::Status ToStatus(const std::invalid_argument& e) {
23
    return absl::InvalidArgumentError(e.what());
24
}

1
template <typename F>
2
auto CallSafely(F&& f) -> absl::StatusOr<decltype(f())> {
3
    try {
4
        return f();
5
    } catch (const std::exception& e) {
6
        return ToStatus(e);
7
    } catch (...) {
8
        return absl::InternalError("unknown exception");
9
    }
10
}
11

12
// 사용
13
absl::StatusOr<int> result = CallSafely([] {
14
    return external_library::do_something();  // throws
15
});

1
class StatusException : public std::exception {
2
public:
3
    explicit StatusException(absl::Status s) : status_(std::move(s)) {}
4
    const char* what() const noexcept override {
5
        return status_.message().data();
6
    }
7
    const absl::Status& status() const { return status_; }
8
private:
9
    absl::Status status_;
10
};
11

12
void ThrowIfNotOk(const absl::Status& s) {
13
    if (!s.ok()) throw StatusException(s);
14
}

1
void DieIfNotOk(const absl::Status& s) {
2
    if (!s.ok()) {
3
        LOG(FATAL) << "operation failed: " << s;
4
    }
5
}

1
#define CHECK_OK(expr) \
2
    do { \
3
        absl::Status _s = (expr); \
4
        if (ABSL_PREDICT_FALSE(!_s.ok())) { \
5
            LOG(FATAL) << "CHECK_OK failed: " << #expr << ": " << _s; \
6
        } \
7
    } while (0)
8

9
CHECK_OK(DoCriticalOp());

1
absl::Status FromErrno(int err) {
2
    return absl::ErrnoToStatus(err, "");
3
}
4

5
absl::Status FromErrnoMessage(int err, absl::string_view ctx) {
6
    return absl::ErrnoToStatus(err, ctx);
7
}

1
// 의사 코드
2
absl::Status ErrnoToStatus(int err, absl::string_view msg) {
3
    auto code = [err]() {
4
        switch (err) {
5
            case EACCES: case EPERM: return absl::StatusCode::kPermissionDenied;
6
            case EEXIST:              return absl::StatusCode::kAlreadyExists;
7
            case ENOENT:              return absl::StatusCode::kNotFound;
8
            case EINVAL:              return absl::StatusCode::kInvalidArgument;
9
            case ENOMEM:              return absl::StatusCode::kResourceExhausted;
10
            case ETIMEDOUT:           return absl::StatusCode::kDeadlineExceeded;
11
            case ENOSYS:              return absl::StatusCode::kUnimplemented;
12
            default:                  return absl::StatusCode::kUnknown;
13
        }
14
    }();
15
    return absl::Status(code,
16
        absl::StrCat(msg, msg.empty() ? "" : ": ", strerror(err)));
17
}

1
absl::Status FromErrorCode(const std::error_code& ec) {
2
    if (!ec) return absl::OkStatus();
3
    if (ec.category() == std::generic_category()) {
4
        return ErrnoToStatus(ec.value(), "");
5
    }
6
    return absl::UnknownError(ec.message());
7
}

1
#include <grpcpp/grpcpp.h>
2

3
absl::Status FromGrpcStatus(const grpc::Status& gs) {
4
    return absl::Status(
5
        static_cast<absl::StatusCode>(gs.error_code()),
6
        gs.error_message());
7
}
8

9
grpc::Status ToGrpcStatus(const absl::Status& s) {
10
    return grpc::Status(
11
        static_cast<grpc::StatusCode>(s.code()),
12
        std::string(s.message()));
13
}

1
absl::Status FromGrpcStatusWithDetails(const grpc::Status& gs) {
2
    auto s = FromGrpcStatus(gs);
3

4
    google::rpc::Status proto;
5
    if (proto.ParseFromString(gs.error_details())) {
6
        for (const auto& detail : proto.details()) {
7
            s.SetPayload(detail.type_url(), absl::Cord(detail.value()));
8
        }
9
    }
10
    return s;
11
}

1
// 회피 — 매 함수마다 try-catch
2
absl::StatusOr<X> MyFunc() {
3
    try {
4
        return ExternalLib::DoIt();
5
    } catch (...) {
6
        return absl::InternalError("...");
7
    }
8
}
9
// 호출 chain 전체에서 반복.
10

11
// Good — wrapper에서 한 번
12
absl::StatusOr<X> ExternalLibSafe::DoIt() {
13
    try { ... }
14
    catch (...) { ... }
15
}
16
absl::StatusOr<X> MyFunc() {
17
    return ExternalLibSafe::DoIt();  // 이미 Status 흐름
18
}

1
// 회피 — Status를 silent하게 throw로 변환
2
void Process() {
3
    auto s = SomeOp();
4
    if (!s.ok()) throw std::runtime_error(s.message());  // 정보 손실
5
}
6

7
// Good — StatusException 사용
8
void Process() {
9
    auto s = SomeOp();
10
    if (!s.ok()) throw StatusException(s);  // Status 전체 보존
11
}

1
// 회피 — errno를 직접 노출
2
int err = ...;
3
return absl::InternalError(absl::StrCat("errno=", err));
4

5
// Good — ErrnoToStatus
6
return absl::ErrnoToStatus(err, "while reading file");

1
// 회피 — exception을 catch해서 OK Status로
2
try {
3
    DoSomething();
4
    return absl::OkStatus();
5
} catch (...) {
6
    return absl::OkStatus();  // 에러를 silent하게 삼킴
7
}
8

9
// Good
10
try {
11
    DoSomething();
12
    return absl::OkStatus();
13
} catch (const std::exception& e) {
14
    return ToStatus(e);
15
}

1
// 회피 — Status code 무시
2
absl::Status s = SomeOp();
3
if (!s.ok()) {
4
    return absl::InternalError(std::string(s.message()));  // canonical code 잃음
5
}
6

7
// Good — 원본 status 그대로 전파
8
absl::Status s = SomeOp();
9
if (!s.ok()) return s;

1
// 회피 — exception을 abort로
2
void Foo() {
3
    try {
4
        ExternalLib::DoIt();
5
    } catch (...) {
6
        std::abort();  // 너무 폭력적
7
    }
8
}
9

10
// Good — 분류 가능하면 status, 진짜 invariant 위반이면 LOG(FATAL)
11
void Foo() {
12
    try {
13
        ExternalLib::DoIt();
14
    } catch (const std::bad_alloc&) {
15
        LOG(FATAL) << "OOM";  // 회복 불가
16
    } catch (const std::exception& e) {
17
        LOG(ERROR) << "operation failed: " << e.what();
18
        // 호출자에게 전파 가능하면 status로
19
    }
20
}