1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
# Remote-procedure calls with JSON over HTTP
I would like to define APIs in a micro/subset language of
C++:
```cc
// api/item.hh
DECLARE_RPC(GET, GetItem,
cs::apps::trycopilotai::protos::GetItemRequest,
cs::apps::trycopilotai::protos::GetItemResponse);
// expands to:
class GetItemRPC : public RPC<GetItemRequest, GetItemResponse> {
virtual cs::apps::trycopilotai::protos::GetItemResponse GET(const cs::apps::trycopilotai::protos::GetItemRequest request) = 0;
}
```
```cc
// api/item.cc
namespace { // use_usings
using ::cs::apps::trycopilotai::protos::GetItemRequest;
using ::cs::apps::trycopilotai::protos::GetItemResponse;
} // namespace
IMPLEMENT_RPC(GET, GetItem, GetItemResponse,
[](const GetItemRequest& request) {
// My c++ code here
return {};
});
// expands to:
class GetItemRPC : public RPC<GetItemRequest, GetItemResponse> {
public:
GetItemResponse GET(const GetItemRequest& request) override {
return ([&](const GetItemRequest& request) {
// My c++ code here
return {};
})(request);
}
};
// With this in cs/net/proto/rpc.hh:
template <typename RequestT, typename ResponseT>
class RPC<RequestT, ResponseT> {
virtual ResultOr<ResponseT> GET(const RequestT& request) {
return NotImplemented();
}
virtual ResultOr<ResponseT> POST(const RequestT& request) {
return NotImplemented();
}
virtual ResultOr<ResponseT> PATCH(const RequestT& request) {
return NotImplemented();
}
virtual ResultOr<ResponseT> DELETE(const RequestT& request) {
return NotImplemented();
}
ResultOr<RequestT> ParseProtoFromHttpRequest(const cs::net::http::Request& request) {
// details hidden
}
};
```
```cc
#include "cs/net/rpc/service.hh"
// api/services.hh
DECLARE_SERVICE(Items, {
GetItemRPC,
// ...
});
// expands to:
class ItemsService : public Service {
std::vector<RPC> GetRPCs() {
return {
GetItemRPC(),
// ...
};
};
};
// With this in cs/net/rpc/service.hh
class Service {
virtual std::vector<RPC> GetRPCs() = 0;
cs::net::http::Response HttpHandler(const http::Request& request) {
for (const auto& rpc : GetRPCs()) {
if (request.method() == "GET") {
return rpc.GET(request);
} else if (request.method() == "POST") {
return rpc.POST(request);
} else if (request.method() == "PATCH") {
return rpc.PATCH(request);
} else if (request.method() == "DELETE") {
return rpc.DELETE(request);
}
}
return {};
}
};
```
```cc
// app/main.cc
// ...
#include api/services.hh
// ...
int main() {
WebApp app;
REGISTER_RPC("/api/item/", ItemsService);
// expands to:
app.AddHandler("/api/item/", ItemsService::HttpHandler);
app.Run(/*port=*/8080)
}
// ...
```
Now this API should be responsive to
`GET http://localhost:8080/api/item`.
This micro implementation of remote-produce calls (RPCs)
should automatically generate:
1. The "binding code" between this single declaration and
the service being available on the port.
1. A class `ItemsService` that implements a
`GetItemResponse GetItem(GetItemRequest request);` method
that the application logic can implement.
1. Support for authentication and authorization
restrictions.
1. Define a network of services and a service registry for
clients to find an active host and port.