Page MenuHomePhabricator
Differential D9281

[blob][reports] Provide identity service endpoint
ClosedPublic
Actions

Authored by bartek on Sep 25 2023, 5:50 AM.
Tags
None
Referenced Files
Unknown Object (File)
Tue, Mar 11, 10:46 PM
Unknown Object (File)
Thu, Mar 6, 6:52 AM
Unknown Object (File)
Tue, Mar 4, 10:08 PM
Unknown Object (File)
Mon, Mar 3, 2:37 PM
Unknown Object (File)
Wed, Feb 26, 11:26 AM
Unknown Object (File)
Wed, Feb 26, 11:25 AM
Unknown Object (File)
Wed, Feb 26, 11:25 AM
Unknown Object (File)
Feb 14 2025, 7:15 PM
View All Files
Subscribers
ashoat
tomek

Details

Reviewers
michal
varun
• jon
Commits
rCOMM3eab259330b4: [blob][reports] Provide identity service endpoint
Summary

Provide identity service endpoint along with AuthService instance for blob and reports service. This is needed for service-to-service token auth and client verification.
Haven't touched backup service yet but it's subject to change as well (after client work is done).

Depends on D9280

Test Plan

Cargo check + ensured that CLI arg is read correctly in blob service

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Revision Contents
Changeset List

PathSize
services/
blob/
src/
4 lines
http/
7 lines
8 lines
reports/
src/
5 lines
http/
9 lines
7 lines

Diff 31596

View Options

services/blob/src/config.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/http/mod.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/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/reports/src/config.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/reports/src/http/mod.rs

Loading...
View Options

services/reports/src/main.rs

Loading...