Page MenuHomePhabricator
Differential D8453

[blob-service] Create business logic abstraction
ClosedPublic
Actions

Authored by bartek on Jul 9 2023, 2:04 PM.
Tags
None
Referenced Files
F4947399: D8453.diff
Wed, Mar 19, 2:40 PM
Unknown Object (File)
Mon, Mar 17, 12:27 AM
Unknown Object (File)
Sat, Mar 15, 9:17 AM
Unknown Object (File)
Fri, Mar 14, 3:26 AM
Unknown Object (File)
Tue, Mar 11, 11:17 AM
Unknown Object (File)
Fri, Mar 7, 6:07 PM
Unknown Object (File)
Fri, Mar 7, 6:07 PM
Unknown Object (File)
Fri, Mar 7, 6:07 PM
View All Files
Subscribers
ashoat
tomek

Details

Reviewers
michal
varun
• patryk
• jon
Commits
rCOMMff3a70e0cb1e: [blob-service] Create business logic abstraction
Summary

Part of ENG-4269.

Previously, the blob service logic was handled directly in the HTTP handlers (and doubled in the gRPC).
We're gonna introduce cleanup tasks too, so decided to abstract it out.

Depends on D8451.

Test Plan

Tested later in the stack

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Event Timeline

bartek created this revision.Jul 9 2023, 2:04 PM
bartek held this revision as a draft.
Herald added subscribers: tomek, ashoat. · View Herald TranscriptJul 9 2023, 2:04 PM
bartek added a child revision: D8454: [blob-service] Implement download logic with new db.Jul 9 2023, 2:05 PM
Harbormaster completed remote builds in B20822: Diff 28509.Jul 9 2023, 2:28 PM
bartek edited the summary of this revision. (Show Details)Jul 9 2023, 11:34 PM
bartek edited the test plan for this revision. (Show Details)
bartek published this revision for review.Jul 10 2023, 12:42 AM
• jon resigned from this revision.Jul 10 2023, 6:07 PM

rust LGTM, would like for someone else to take a look

varun accepted this revision.Jul 13 2023, 10:17 AM
This revision is now accepted and ready to land.Jul 13 2023, 10:17 AM
bartek edited the summary of this revision. (Show Details)Jul 21 2023, 1:15 AM
bartek added a parent revision: D8451: [blob-service] DB: Add holder management methods.
bartek removed a parent revision: D8452: [blob-service] DB: Add remaining client methods.
bartek updated this revision to Diff 28912.Jul 21 2023, 1:52 AM

Rebase

Harbormaster failed remote builds in B21101: Diff 28912!Jul 25 2023, 1:38 AM
This revision was landed with ongoing or failed builds.Jul 25 2023, 1:44 AM
Closed by commit rCOMMff3a70e0cb1e: [blob-service] Create business logic abstraction (authored by bartek). · Explain Why
This revision was automatically updated to reflect the committed changes.
bartek added a commit: rCOMMff3a70e0cb1e: [blob-service] Create business logic abstraction.

Revision Contents
Changeset List

PathSize
services/
blob/
src/
1 line
77 lines
4 lines

Diff 28992

View Options

services/blob/src/main.rs

  • This file was added.
#pragma once
#include <grpcpp/grpcpp.h>
#include <iostream>
#include <memory>
#include <string>
namespace comm {
namespace network {
namespace reactor {
struct ServerBidiReactorStatus {
grpc::Status status = grpc::Status::OK;
bool sendLastResponse = false;
ServerBidiReactorStatus(
grpc::Status status = grpc::Status::OK,
bool sendLastResponse = false)
: status(status), sendLastResponse(sendLastResponse) {
}
};
template <class Request, class Response>
class ServerBidiReactorBase
: public grpc::ServerBidiReactor<Request, Response> {
Request request;
Response response;
protected:
ServerBidiReactorStatus status;
bool readingAborted = false;
public:
ServerBidiReactorBase();
void OnDone() override;
void OnReadDone(bool ok) override;
void OnWriteDone(bool ok) override;
void terminate(ServerBidiReactorStatus status);
virtual std::unique_ptr<ServerBidiReactorStatus>
handleRequest(Request request, Response *response) = 0;
virtual void initialize(){};
virtual void doneCallback(){};
};
template <class Request, class Response>
ServerBidiReactorBase<Request, Response>::ServerBidiReactorBase() {
this->initialize();
this->StartRead(&this->request);
}
template <class Request, class Response>
void ServerBidiReactorBase<Request, Response>::OnDone() {
this->doneCallback();
delete this;
}
template <class Request, class Response>
void ServerBidiReactorBase<Request, Response>::terminate(
ServerBidiReactorStatus status) {
this->status = status;
if (this->status.sendLastResponse) {
this->StartWriteAndFinish(
&this->response, grpc::WriteOptions(), this->status.status);
} else {
this->Finish(this->status.status);
}
}
template <class Request, class Response>
void ServerBidiReactorBase<Request, Response>::OnReadDone(bool ok) {
if (!ok) {
this->readingAborted = true;
this->terminate(ServerBidiReactorStatus(
grpc::Status(grpc::StatusCode::ABORTED, "no more reads")));
return;
}
try {
this->response = Response();
std::unique_ptr<ServerBidiReactorStatus> status =
this->handleRequest(this->request, &this->response);
if (status != nullptr) {
this->terminate(*status);
return;
}
this->StartWrite(&this->response);
} catch (std::runtime_error &e) {
this->terminate(ServerBidiReactorStatus(
grpc::Status(grpc::StatusCode::INTERNAL, e.what())));
}
}
template <class Request, class Response>
void ServerBidiReactorBase<Request, Response>::OnWriteDone(bool ok) {
if (!ok) {
this->terminate(ServerBidiReactorStatus(
grpc::Status(grpc::StatusCode::ABORTED, "write failed")));
return;
}
this->StartRead(&this->request);
}
} // namespace reactor
} // namespace network
} // namespace comm
View Options

services/blob/src/service.rs

  • This file was added.
#pragma once
#include <grpcpp/grpcpp.h>
#include <iostream>
#include <memory>
#include <string>
namespace comm {
namespace network {
namespace reactor {
struct ServerBidiReactorStatus {
grpc::Status status = grpc::Status::OK;
bool sendLastResponse = false;
ServerBidiReactorStatus(
grpc::Status status = grpc::Status::OK,
bool sendLastResponse = false)
: status(status), sendLastResponse(sendLastResponse) {
}
};
template <class Request, class Response>
class ServerBidiReactorBase
: public grpc::ServerBidiReactor<Request, Response> {
Request request;
Response response;
protected:
ServerBidiReactorStatus status;
bool readingAborted = false;
public:
ServerBidiReactorBase();
void OnDone() override;
void OnReadDone(bool ok) override;
void OnWriteDone(bool ok) override;
void terminate(ServerBidiReactorStatus status);
virtual std::unique_ptr<ServerBidiReactorStatus>
handleRequest(Request request, Response *response) = 0;
virtual void initialize(){};
virtual void doneCallback(){};
};
template <class Request, class Response>
ServerBidiReactorBase<Request, Response>::ServerBidiReactorBase() {
this->initialize();
this->StartRead(&this->request);
}
template <class Request, class Response>
void ServerBidiReactorBase<Request, Response>::OnDone() {
this->doneCallback();
delete this;
}
template <class Request, class Response>
void ServerBidiReactorBase<Request, Response>::terminate(
ServerBidiReactorStatus status) {
this->status = status;
if (this->status.sendLastResponse) {
this->StartWriteAndFinish(
&this->response, grpc::WriteOptions(), this->status.status);
} else {
this->Finish(this->status.status);
}
}
template <class Request, class Response>
void ServerBidiReactorBase<Request, Response>::OnReadDone(bool ok) {
if (!ok) {
this->readingAborted = true;
this->terminate(ServerBidiReactorStatus(
grpc::Status(grpc::StatusCode::ABORTED, "no more reads")));
return;
}
try {
this->response = Response();
std::unique_ptr<ServerBidiReactorStatus> status =
this->handleRequest(this->request, &this->response);
if (status != nullptr) {
this->terminate(*status);
return;
}
this->StartWrite(&this->response);
} catch (std::runtime_error &e) {
this->terminate(ServerBidiReactorStatus(
grpc::Status(grpc::StatusCode::INTERNAL, e.what())));
}
}
template <class Request, class Response>
void ServerBidiReactorBase<Request, Response>::OnWriteDone(bool ok) {
if (!ok) {
this->terminate(ServerBidiReactorStatus(
grpc::Status(grpc::StatusCode::ABORTED, "write failed")));
return;
}
this->StartRead(&this->request);
}
} // namespace reactor
} // namespace network
} // namespace comm
View Options

services/blob/src/tools.rs

  • This file was added.
#pragma once
#include <grpcpp/grpcpp.h>
#include <iostream>
#include <memory>
#include <string>
namespace comm {
namespace network {
namespace reactor {
struct ServerBidiReactorStatus {
grpc::Status status = grpc::Status::OK;
bool sendLastResponse = false;
ServerBidiReactorStatus(
grpc::Status status = grpc::Status::OK,
bool sendLastResponse = false)
: status(status), sendLastResponse(sendLastResponse) {
}
};
template <class Request, class Response>
class ServerBidiReactorBase
: public grpc::ServerBidiReactor<Request, Response> {
Request request;
Response response;
protected:
ServerBidiReactorStatus status;
bool readingAborted = false;
public:
ServerBidiReactorBase();
void OnDone() override;
void OnReadDone(bool ok) override;
void OnWriteDone(bool ok) override;
void terminate(ServerBidiReactorStatus status);
virtual std::unique_ptr<ServerBidiReactorStatus>
handleRequest(Request request, Response *response) = 0;
virtual void initialize(){};
virtual void doneCallback(){};
};
template <class Request, class Response>
ServerBidiReactorBase<Request, Response>::ServerBidiReactorBase() {
this->initialize();
this->StartRead(&this->request);
}
template <class Request, class Response>
void ServerBidiReactorBase<Request, Response>::OnDone() {
this->doneCallback();
delete this;
}
template <class Request, class Response>
void ServerBidiReactorBase<Request, Response>::terminate(
ServerBidiReactorStatus status) {
this->status = status;
if (this->status.sendLastResponse) {
this->StartWriteAndFinish(
&this->response, grpc::WriteOptions(), this->status.status);
} else {
this->Finish(this->status.status);
}
}
template <class Request, class Response>
void ServerBidiReactorBase<Request, Response>::OnReadDone(bool ok) {
if (!ok) {
this->readingAborted = true;
this->terminate(ServerBidiReactorStatus(
grpc::Status(grpc::StatusCode::ABORTED, "no more reads")));
return;
}
try {
this->response = Response();
std::unique_ptr<ServerBidiReactorStatus> status =
this->handleRequest(this->request, &this->response);
if (status != nullptr) {
this->terminate(*status);
return;
}
this->StartWrite(&this->response);
} catch (std::runtime_error &e) {
this->terminate(ServerBidiReactorStatus(
grpc::Status(grpc::StatusCode::INTERNAL, e.what())));
}
}
template <class Request, class Response>
void ServerBidiReactorBase<Request, Response>::OnWriteDone(bool ok) {
if (!ok) {
this->terminate(ServerBidiReactorStatus(
grpc::Status(grpc::StatusCode::ABORTED, "write failed")));
return;
}
this->StartRead(&this->request);
}
} // namespace reactor
} // namespace network
} // namespace comm