SY-3961: Arc Ranges (Create & End)

client/cpp/ranger/ranger.cpp

@@ -116,4 +116,12 @@ Client::create(const std::string &name, x::telem::TimeRange time_range) const {
     return {rng, err};
 }
 
+x::errors::Error
+Client::set_end(const x::uuid::UUID &key, const x::telem::TimeStamp end) const {
+    auto req = grpc::ranger::SetEndRequest();
+    req.set_key(key.to_string());
+    req.set_end(end.nanoseconds());
+    return set_end_client->send("/range/set-end", req).second;
+}
+
 }

client/cpp/ranger/ranger.h

@@ -32,16 +32,22 @@ using RetrieveClient = freighter::
 using CreateClient = freighter::
     UnaryClient<grpc::ranger::CreateRequest, grpc::ranger::CreateResponse>;
 
+/// @brief type alias for the transport used to set the end bound of a range.
+using SetEndClient = freighter::
+    UnaryClient<grpc::ranger::SetEndRequest, google::protobuf::Empty>;
+
 /// @brief a client for performing operations on the ranges in a Synnax cluster.
 class Client {
 public:
     Client(
         std::unique_ptr<RetrieveClient> retrieve_client,
         std::unique_ptr<CreateClient> create_client,
+        std::unique_ptr<SetEndClient> set_end_client,
         const ranger::kv::Client &kv_client
     ):
         retrieve_client(std::move(retrieve_client)),
         create_client(std::move(create_client)),
+        set_end_client(std::move(set_end_client)),
         kv(kv_client) {}
 
     /// @brief retrieves the range with the given key.
@@ -70,11 +76,18 @@ class Client {
     [[nodiscard]] std::pair<Range, x::errors::Error>
     create(const std::string &name, x::telem::TimeRange time_range) const;
 
+    /// @brief sets the end bound of the range with the given key in a single request,
+    /// preserving all other fields.
+    [[nodiscard]] x::errors::Error
+    set_end(const Key &key, x::telem::TimeStamp end) const;
+
 private:
     /// @brief range retrieval transport.
     std::unique_ptr<RetrieveClient> retrieve_client;
     /// @brief create retrieval transport.
     std::unique_ptr<CreateClient> create_client;
+    /// @brief set-end transport.
+    std::unique_ptr<SetEndClient> set_end_client;
     /// @brief range kv get transport.
     ranger::kv::Client kv;
 

client/cpp/ranger/ranger_test.cpp

@@ -49,6 +49,29 @@ TEST(RangerTests, testRetrieveByKey) {
     ASSERT_EQ(got.time_range.end, x::telem::TimeStamp(100));
 }
 
+/// @brief it should set the end bound of a range while preserving its other fields.
+TEST(RangerTests, testSetEnd) {
+    const auto client = new_test_client();
+    const auto range = ASSERT_NIL_P(client.ranges.create(
+        "test",
+        x::telem::TimeRange(x::telem::TimeStamp(30), x::telem::TimeStamp(100))
+    ));
+    ASSERT_NIL(client.ranges.set_end(range.key, x::telem::TimeStamp(500)));
+    const auto got = ASSERT_NIL_P(client.ranges.retrieve_by_key(range.key));
+    ASSERT_EQ(got.name, "test");
+    ASSERT_EQ(got.time_range.start, x::telem::TimeStamp(30));
+    ASSERT_EQ(got.time_range.end, x::telem::TimeStamp(500));
+}
+
+/// @brief it should return an error when setting the end of a nonexistent range.
+TEST(RangerTests, testSetEndNotFound) {
+    const auto client = new_test_client();
+    ASSERT_OCCURRED_AS(
+        client.ranges.set_end(x::uuid::create(), x::telem::TimeStamp(500)),
+        x::errors::NOT_FOUND
+    );
+}
+
 /// @brief it should retrieve a range by its name.
 TEST(RangerTests, testRetrieveByName) {
     const auto client = new_test_client();

client/cpp/synnax.h

@@ -189,6 +189,7 @@ class Synnax {
         ranges(
             std::move(this->t.range_retrieve),
             std::move(this->t.range_create),
+            std::move(this->t.range_set_end),
             ranger::kv::Client(
                 this->t.range_kv_get,
                 this->t.range_kv_set,

client/cpp/transport.cpp

@@ -79,6 +79,10 @@ Transport::Transport(
         grpc::ranger::CreateRequest,
         grpc::ranger::CreateResponse,
         grpc::ranger::RangeCreateService>>(pool, base_target);
+    this->range_set_end = std::make_unique<freighter::grpc::UnaryClient<
+        grpc::ranger::SetEndRequest,
+        google::protobuf::Empty,
+        grpc::ranger::RangeSetEndService>>(pool, base_target);
     this->range_kv_delete = std::make_shared<freighter::grpc::UnaryClient<
         grpc::kv::DeleteRequest,
         google::protobuf::Empty,
@@ -180,6 +184,7 @@ void Transport::use(const std::shared_ptr<freighter::Middleware> &mw) const {
     chan_retrieve->use(mw);
     range_retrieve->use(mw);
     range_create->use(mw);
+    range_set_end->use(mw);
     range_kv_delete->use(mw);
     range_kv_get->use(mw);
     range_kv_set->use(mw);

client/cpp/transport.h

@@ -39,6 +39,7 @@ struct Transport {
     std::shared_ptr<channel::RetrieveClient> chan_retrieve;
     std::unique_ptr<ranger::RetrieveClient> range_retrieve;
     std::unique_ptr<ranger::CreateClient> range_create;
+    std::unique_ptr<ranger::SetEndClient> range_set_end;
     std::shared_ptr<ranger::kv::DeleteClient> range_kv_delete;
     std::shared_ptr<ranger::kv::GetClient> range_kv_get;
     std::shared_ptr<ranger::kv::SetClient> range_kv_set;

core/pkg/api/layer.go

@@ -83,6 +83,7 @@ type Transport struct {
 	RangeRetrieve freighter.UnaryServer[ranger.RetrieveRequest, ranger.RetrieveResponse]
 	RangeDelete   freighter.UnaryServer[ranger.DeleteRequest, types.Nil]
 	RangeRename   freighter.UnaryServer[ranger.RenameRequest, types.Nil]
+	RangeSetEnd   freighter.UnaryServer[ranger.SetEndRequest, types.Nil]
 	// KV
 	KVGet    freighter.UnaryServer[kv.GetRequest, kv.GetResponse]
 	KVSet    freighter.UnaryServer[kv.SetRequest, types.Nil]
@@ -281,6 +282,7 @@ func (l *Layer) BindTo(t Transport) {
 		t.RangeRetrieve,
 		t.RangeDelete,
 		t.RangeRename,
+		t.RangeSetEnd,
 
 		// KV
 		t.KVGet,
@@ -447,6 +449,7 @@ func (l *Layer) BindTo(t Transport) {
 	t.RangeCreate.BindHandler(fgorp.CreateWriteUnaryHandler(db, l.Range.Create))
 	t.RangeDelete.BindHandler(fgorp.CreateWriteUnaryHandler(db, l.Range.Delete))
 	t.RangeRename.BindHandler(fgorp.CreateWriteUnaryHandler(db, l.Range.Rename))
+	t.RangeSetEnd.BindHandler(fgorp.CreateWriteUnaryHandler(db, l.Range.SetEnd))
 
 	// KV
 	t.KVGet.BindHandler(l.KV.Get)

core/pkg/api/ranger/ranger.go

@@ -203,6 +203,26 @@ func (s *Service) Rename(
 	return types.Nil{}, s.internal.NewWriter(tx).Rename(ctx, req.Key, req.Name)
 }
 
+type SetEndRequest struct {
+	Key ranger.Key      `json:"key" msgpack:"key"`
+	End telem.TimeStamp `json:"end" msgpack:"end"`
+}
+
+func (s *Service) SetEnd(
+	ctx context.Context,
+	tx gorp.Tx,
+	req SetEndRequest,
+) (types.Nil, error) {
+	if err := s.access.NewEnforcer(tx).Enforce(ctx, access.Request{
+		Subject: auth.GetSubject(ctx),
+		Action:  access.ActionUpdate,
+		Objects: []ontology.ID{ranger.OntologyID(req.Key)},
+	}); err != nil {
+		return types.Nil{}, err
+	}
+	return types.Nil{}, s.internal.NewWriter(tx).SetEnd(ctx, req.Key, req.End)
+}
+
 type DeleteRequest struct {
 	Keys []ranger.Key `json:"keys" msgpack:"keys"`
 }