17713096990

Committed 14 Sep 2025 03:23PM UTC coverage: 55.184% (+0.9%) from 54.268%

Build # 17713096990

Build Type

push

github

Committed by

ivanallen

Commit Message

extract rsm to common

Signed-off-by: allen <1007729991@qq.com>

Coverage Stats

1660 of 4120 branches covered (40.29%)

Branch coverage included in aggregate %.

166 of 187 new or added lines in 13 files covered. (88.77%)

101 existing lines in 7 files now uncovered.

1938 of 2400 relevant lines covered (80.75%)

513.03 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

32.14

/src/deva/deva_op_factory.h

#pragma once

#include "pain/proto/deva_store.pb.h"
#include "common/rsm/container_op.h"
#include "common/rsm/op_factory.h"

#define BRANCH(name)                                                                                                   \
    case OpType::k##name:                                                                                              \
        return create_op<OpType::k##name, proto::deva::store::name##Request, proto::deva::store::name##Response>(      \
            version, rsm);                                                                                             \
        break;

namespace pain::deva {
class Deva;

using OpPtr = common::OpPtr;
using RsmPtr = common::RsmPtr;

template <typename Request, typename Response>
using ContainerOp = common::ContainerOp<Deva, Request, Response>;

enum class OpType : uint32_t {
    kInvalid = 0,
    // DevaOp: 1 ~ 100
    DEFINE_RSM_OP(1, CreateFile, true),
    DEFINE_RSM_OP(2, CreateDir, true),
    DEFINE_RSM_OP(3, RemoveFile, true),
    DEFINE_RSM_OP(4, SealFile, true),
    DEFINE_RSM_OP(5, CreateChunk, true),
    DEFINE_RSM_OP(6, CheckInChunk, true),
    DEFINE_RSM_OP(7, SealChunk, true),
    DEFINE_RSM_OP(8, SealAndNewChunk, true),
    DEFINE_RSM_OP(9, ReadDir, false),
    DEFINE_RSM_OP(10, GetFileInfo, false),
    DEFINE_RSM_OP(20, ManusyaHeartbeat, false),
    DEFINE_RSM_OP(21, ListManusya, false),
    DEFINE_RSM_OP(100, MaxDevaOp, true),
};

template <OpType OpType, typename Request, typename Response>
OpPtr create_op(int32_t version, RsmPtr rsm) {
    Request request;
    OpPtr op = nullptr;

    if constexpr (OpType < OpType::kMaxDevaOp) {
        op = new ContainerOp<Request, Response>(version, static_cast<uint32_t>(OpType), rsm, request, nullptr);
    }
    return op;
}

class DevaOpFactory : public common::OpFactory {
public:
    OpPtr create(uint32_t op_type, int32_t version, RsmPtr rsm) override {
        switch (static_cast<OpType>(op_type)) {
            BRANCH(CreateFile)
            BRANCH(CreateDir)
            BRANCH(ReadDir)
            BRANCH(RemoveFile)
            BRANCH(SealFile)
            BRANCH(CreateChunk)
            BRANCH(CheckInChunk)
            BRANCH(SealChunk)
            BRANCH(SealAndNewChunk)
        default:
            BOOST_ASSERT_MSG(false, fmt::format("unknown op type: {}", op_type).c_str());
        }
        return nullptr;
    }
};

} // namespace pain::deva

1	#pragma once
2
3	#include "pain/proto/deva_store.pb.h"
4	#include "common/rsm/container_op.h"
5	#include "common/rsm/op_factory.h"
6
7	#define BRANCH(name) \
8	case OpType::k##name: \
9	return create_op<OpType::k##name, proto::deva::store::name##Request, proto::deva::store::name##Response>( \
10	version, rsm); \
11	break;
12
13	namespace pain::deva {
14	class Deva;
15
16	using OpPtr = common::OpPtr;
17	using RsmPtr = common::RsmPtr;
18
19	template <typename Request, typename Response>
20	using ContainerOp = common::ContainerOp<Deva, Request, Response>;
21
22	enum class OpType : uint32_t {
23	kInvalid = 0,
24	// DevaOp: 1 ~ 100
25	DEFINE_RSM_OP(1, CreateFile, true),
26	DEFINE_RSM_OP(2, CreateDir, true),
27	DEFINE_RSM_OP(3, RemoveFile, true),
28	DEFINE_RSM_OP(4, SealFile, true),
29	DEFINE_RSM_OP(5, CreateChunk, true),
30	DEFINE_RSM_OP(6, CheckInChunk, true),
31	DEFINE_RSM_OP(7, SealChunk, true),
32	DEFINE_RSM_OP(8, SealAndNewChunk, true),
33	DEFINE_RSM_OP(9, ReadDir, false),
34	DEFINE_RSM_OP(10, GetFileInfo, false),
35	DEFINE_RSM_OP(20, ManusyaHeartbeat, false),
36	DEFINE_RSM_OP(21, ListManusya, false),
37	DEFINE_RSM_OP(100, MaxDevaOp, true),
38	};
39
40	template <OpType OpType, typename Request, typename Response>
41	OpPtr create_op(int32_t version, RsmPtr rsm) {	46✔
42	Request request;	46!
43	OpPtr op = nullptr;	46✔
44
45	if constexpr (OpType < OpType::kMaxDevaOp) {
46	op = new ContainerOp<Request, Response>(version, static_cast<uint32_t>(OpType), rsm, request, nullptr);	46!
47	}
48	return op;	94✔
49	}	47✔
50
51	class DevaOpFactory : public common::OpFactory {
52	public:
53	OpPtr create(uint32_t op_type, int32_t version, RsmPtr rsm) override {	45✔
54	switch (static_cast<OpType>(op_type)) {	45!
55	BRANCH(CreateFile)	22!
56	BRANCH(CreateDir)	24!
NEW 57	BRANCH(ReadDir)	×
NEW 58	BRANCH(RemoveFile)	×
NEW 59	BRANCH(SealFile)	×
NEW 60	BRANCH(CreateChunk)	×
NEW 61	BRANCH(CheckInChunk)	×
NEW 62	BRANCH(SealChunk)	×
NEW 63	BRANCH(SealAndNewChunk)	×
64	default:
65	BOOST_ASSERT_MSG(false, fmt::format("unknown op type: {}", op_type).c_str());
66	}
NEW 67	return nullptr;	×
68	}
69	};
70
71	} // namespace pain::deva

paticcaa / pain / 17713096990

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous