Page MenuHomePhabricator
Differential D3856

[native] Bump `react-native-svg` to `12.3.0`
ClosedPublic
Actions

Authored by atul on Apr 27 2022, 7:35 AM.
Tags
None
Referenced Files
F5077970: D3856.diff
Sat, Mar 29, 12:07 AM
Unknown Object (File)
Thu, Mar 27, 12:58 AM
Unknown Object (File)
Tue, Mar 25, 6:57 PM
Unknown Object (File)
Mon, Mar 24, 2:37 PM
Unknown Object (File)
Thu, Mar 20, 10:03 AM
Unknown Object (File)
Tue, Mar 18, 4:11 AM
Unknown Object (File)
Thu, Mar 6, 11:50 AM
Unknown Object (File)
Mon, Mar 3, 2:29 PM
View All Files
Subscribers
• abosh
• adrian
• karol

Details

Reviewers
• jacek
tomek
ashoat
Commits
rCOMMbd743e58e318: [native] Bump `react-native-svg` to `12.3.0`
Summary

Downstream dependencies have issues surfaced by yarn audit

Checked the release notes: https://github.com/react-native-svg/react-native-svg/releases and didn't find any breaking changes

Depends on D3855

Test Plan

CI

Diff Detail

Repository
rCOMM Comm
Branch
landapr27 (branched from master)
Lint
No Lint Coverage
Unit
No Test Coverage

Event Timeline

atul created this revision.Apr 27 2022, 7:35 AM
Herald added subscribers: • abosh, • karol, • adrian. · View Herald TranscriptApr 27 2022, 7:35 AM
Harbormaster completed remote builds in B8602: Diff 11986.Apr 27 2022, 7:40 AM
atul requested review of this revision.Apr 27 2022, 7:40 AM
atul edited the summary of this revision. (Show Details)Apr 27 2022, 8:17 AM
atul added a parent revision: D3855: [keyserver] Bump `firebase-admin` to `10.1.0`.
atul added a child revision: D3857: [yarn] Bump transitive dependencies of `expo`.
ashoat accepted this revision.Apr 27 2022, 2:30 PM
  1. Please make sure to make me a blocking reviewer on diffs that affect dependencies in the future
  2. Can you also test wherever we use react-native-svg to make sure it still works as expected?
This revision is now accepted and ready to land.Apr 27 2022, 2:30 PM
atul added a comment.Apr 27 2022, 2:31 PM

Can you also test wherever we use react-native-svg to make sure it still works as expected?

Yeah, we only use it to display the "background" tab illustration. I'll check it before landing.

atul updated this revision to Diff 12013.Apr 27 2022, 2:47 PM

cherrypick before testing before landing

Harbormaster completed remote builds in B8623: Diff 12013.Apr 27 2022, 2:52 PM
atul updated this revision to Diff 12050.Apr 28 2022, 10:53 AM

include changes to Podfile.lock

Harbormaster completed remote builds in B8659: Diff 12050.Apr 28 2022, 10:58 AM
atul added a comment.Apr 28 2022, 11:26 AM

Good thing I didn't land it before testing the "background illustration" SVG.

I'm on my old MacBook Air and it looks like my ruby environment set up was out-of-date. As a result pod install failed silently and so the Podfile.lock file never updated.

Fixed the ruby environment, ensured that pod install ran correctly, ensured that Podfile.lock changed as expected, and made sure that the "background illustration" SVG looks as expected on iOS:

Simulator Screen Shot - iPhone 13 mini - 2022-04-28 at 13.26.21.png (2×1 px, 213 KB)

atul updated this revision to Diff 12054.Apr 28 2022, 11:28 AM

rebase before landing

This revision was landed with ongoing or failed builds.Apr 28 2022, 11:28 AM
Closed by commit rCOMMbd743e58e318: [native] Bump `react-native-svg` to `12.3.0` (authored by atul). · Explain Why
This revision was automatically updated to reflect the committed changes.
atul added a commit: rCOMMbd743e58e318: [native] Bump `react-native-svg` to `12.3.0`.
Harbormaster completed remote builds in B8661: Diff 12054.Apr 28 2022, 11:32 AM
atul mentioned this in D3889: [web] Add background illustration to background tab.May 2 2022, 11:55 AM
atul mentioned this in rCOMMc7fdc0b41542: [web] Add background illustration to background tab.May 4 2022, 6:22 AM

Revision Contents
Changeset List

PathSize
native/
ios/
6 lines
2 lines
65 lines

Diff 12054

View Options

native/ios/Podfile.lock

#pragma once #pragma once
#include "Constants.h" #include "Constants.h"
#include "ServerReadReactorBase.h" #include "ServerReadReactorBase.h"
#include "ServiceBlobClient.h"
#include "Tools.h"
#include "../_generated/backup.grpc.pb.h" #include "../_generated/backup.grpc.pb.h"
#include "../_generated/backup.pb.h" #include "../_generated/backup.pb.h"
#include <iostream> #include <iostream>
#include <memory> #include <memory>
#include <string> #include <string>
namespace comm { namespace comm {
namespace network { namespace network {
namespace reactor { namespace reactor {
class SendLogReactor : public ServerReadReactorBase< class SendLogReactor : public ServerReadReactorBase<
backup::SendLogRequest, backup::SendLogRequest,
google::protobuf::Empty> { google::protobuf::Empty> {
enum class State { enum class State {
USER_ID = 1, USER_ID = 1,
LOG_CHUNK = 2, BACKUP_ID = 2,
LOG_HASH = 3,
LOG_CHUNK = 4,
}; };
enum class PersistenceMethod { enum class PersistenceMethod {
UNKNOWN = 0, UNKNOWN = 0,
DB = 1, DB = 1,
BLOB = 2, BLOB = 2,
}; };
State state = State::USER_ID; State state = State::USER_ID;
PersistenceMethod persistenceMethod = PersistenceMethod::UNKNOWN; PersistenceMethod persistenceMethod = PersistenceMethod::UNKNOWN;
std::string userID; std::string userID;
std::string backupID;
void storeInDatabase(const std::string &data) { std::string hash;
} // either the value itself which is a dump of a single operation (if
// `persistedInBlob` is false) or the holder to blob (if `persistedInBlob` is
void storeInBlob(const std::string &data) { // true)
} std::string value;
std::mutex reactorStateMutex;
std::condition_variable waitingForBlobClientCV;
std::mutex waitingForBlobClientCVMutex;
std::shared_ptr<reactor::BlobPutClientReactor> putReactor;
ServiceBlobClient blobClient;
void storeInDatabase();
std::string generateHolder();
std::string generateLogID();
void initializePutReactor();
public: public:
using ServerReadReactorBase<backup::SendLogRequest, google::protobuf::Empty>:: using ServerReadReactorBase<backup::SendLogRequest, google::protobuf::Empty>::
ServerReadReactorBase; ServerReadReactorBase;
std::unique_ptr<grpc::Status> std::unique_ptr<grpc::Status>
readRequest(backup::SendLogRequest request) override; readRequest(backup::SendLogRequest request) override;
void doneCallback() override; void doneCallback() override;
void terminateCallback() override;
}; };
void SendLogReactor::storeInDatabase() {
// TODO handle attachment holders
database::LogItem logItem(
this->backupID,
this->generateLogID(),
(this->persistenceMethod == PersistenceMethod::BLOB),
this->value,
{});
database::DatabaseManager::getInstance().putLogItem(logItem);
}
std::string SendLogReactor::generateHolder() {
// TODO replace mock
return generateRandomString();
}
std::string SendLogReactor::generateLogID() {
// TODO replace mock
return generateRandomString();
}
void SendLogReactor::initializePutReactor() {
if (this->value.empty() || this->hash.empty()) {
throw std::runtime_error("not enough data to initialize put reactor");
}
if (this->putReactor == nullptr) {
this->putReactor = std::make_shared<reactor::BlobPutClientReactor>(
this->value, this->hash, &this->waitingForBlobClientCV);
this->blobClient.put(this->putReactor);
}
}
std::unique_ptr<grpc::Status> std::unique_ptr<grpc::Status>
SendLogReactor::readRequest(backup::SendLogRequest request) { SendLogReactor::readRequest(backup::SendLogRequest request) {
// we make sure that the blob client's state is flushed to the main memory
// as there may be multiple threads from the pool taking over here
const std::lock_guard<std::mutex> lock(this->reactorStateMutex);
switch (this->state) { switch (this->state) {
case State::USER_ID: { case State::USER_ID: {
if (!request.has_userid()) { if (!request.has_userid()) {
throw std::runtime_error("user id expected but not received"); throw std::runtime_error("user id expected but not received");
} }
this->userID = request.userid(); this->userID = request.userid();
this->state = State::BACKUP_ID;
return nullptr;
};
case State::BACKUP_ID: {
if (!request.has_backupid()) {
throw std::runtime_error("backup id expected but not received");
}
this->backupID = request.backupid();
this->state = State::LOG_HASH;
return nullptr;
};
case State::LOG_HASH: {
if (!request.has_loghash()) {
throw std::runtime_error("log hash expected but not received");
}
this->hash = request.loghash();
this->state = State::LOG_CHUNK; this->state = State::LOG_CHUNK;
return nullptr; return nullptr;
}; };
case State::LOG_CHUNK: { case State::LOG_CHUNK: {
if (!request.has_logdata()) { if (!request.has_logdata()) {
throw std::runtime_error("log data expected but not received"); throw std::runtime_error("log data expected but not received");
} }
if (this->persistenceMethod == PersistenceMethod::DB) { std::unique_ptr<std::string> chunk =
throw std::runtime_error( std::make_unique<std::string>(std::move(*request.mutable_logdata()));
"storing multiple chunks in the database is not allowed"); if (chunk->size() == 0) {
return std::make_unique<grpc::Status>(grpc::Status::OK);
} }
std::string *chunk = request.mutable_logdata();
// decide if keep in DB or upload to blob // decide if keep in DB or upload to blob
if (chunk->size() <= LOG_DATA_SIZE_DATABASE_LIMIT) { if (chunk->size() <= LOG_DATA_SIZE_DATABASE_LIMIT) {
if (this->persistenceMethod == PersistenceMethod::UNKNOWN) { if (this->persistenceMethod == PersistenceMethod::UNKNOWN) {
this->persistenceMethod = PersistenceMethod::DB; this->persistenceMethod = PersistenceMethod::DB;
this->storeInDatabase(*chunk); this->value = std::move(*chunk);
this->storeInDatabase();
return std::make_unique<grpc::Status>(grpc::Status::OK);
} else if (this->persistenceMethod == PersistenceMethod::BLOB) { } else if (this->persistenceMethod == PersistenceMethod::BLOB) {
this->storeInBlob(*chunk); this->initializePutReactor();
this->putReactor->scheduleSendingDataChunk(std::move(chunk));
} }
throw std::runtime_error( throw std::runtime_error(
"error - invalid persistence state for chunk smaller than database " "error - invalid persistence state for chunk smaller than database "
"limit"); "limit");
} else { } else {
if (this->persistenceMethod != PersistenceMethod::UNKNOWN && if (this->persistenceMethod != PersistenceMethod::UNKNOWN &&
this->persistenceMethod != PersistenceMethod::BLOB) { this->persistenceMethod != PersistenceMethod::BLOB) {
throw std::runtime_error( throw std::runtime_error(
"error - invalid persistence state, uploading to blob should be " "error - invalid persistence state, uploading to blob should be "
"continued but it is not"); "continued but it is not");
} }
if (this->persistenceMethod == PersistenceMethod::UNKNOWN) {
this->persistenceMethod = PersistenceMethod::BLOB; this->persistenceMethod = PersistenceMethod::BLOB;
this->storeInBlob(*chunk);
} }
std::cout << "log data received " << chunk->size() << std::endl; if (this->value.empty()) {
this->value = this->generateHolder();
}
this->initializePutReactor();
this->putReactor->scheduleSendingDataChunk(std::move(chunk));
}
return nullptr; return nullptr;
}; };
} }
throw std::runtime_error("send log - invalid state"); throw std::runtime_error("send log - invalid state");
} }
void SendLogReactor::terminateCallback() {
const std::lock_guard<std::mutex> lock(this->reactorStateMutex);
if (this->persistenceMethod == PersistenceMethod::DB ||
this->putReactor == nullptr) {
return;
}
this->putReactor->scheduleSendingDataChunk(std::make_unique<std::string>(""));
std::unique_lock<std::mutex> lock2(this->waitingForBlobClientCVMutex);
this->waitingForBlobClientCV.wait(lock2);
// store in db only when we successfully upload chunks
this->storeInDatabase();
}
void SendLogReactor::doneCallback() { void SendLogReactor::doneCallback() {
const std::lock_guard<std::mutex> lock(this->reactorStateMutex);
// TODO implement // TODO implement
std::cout << "receive logs done " << this->status.error_code() << "/" std::cout << "receive logs done " << this->status.error_code() << "/"
<< this->status.error_message() << std::endl; << this->status.error_message() << std::endl;
} }
} // namespace reactor } // namespace reactor
} // namespace network } // namespace network
} // namespace comm } // namespace comm
View Options

native/package.json

#pragma once #pragma once
#include "Constants.h" #include "Constants.h"
#include "ServerReadReactorBase.h" #include "ServerReadReactorBase.h"
#include "ServiceBlobClient.h"
#include "Tools.h"
#include "../_generated/backup.grpc.pb.h" #include "../_generated/backup.grpc.pb.h"
#include "../_generated/backup.pb.h" #include "../_generated/backup.pb.h"
#include <iostream> #include <iostream>
#include <memory> #include <memory>
#include <string> #include <string>
namespace comm { namespace comm {
namespace network { namespace network {
namespace reactor { namespace reactor {
class SendLogReactor : public ServerReadReactorBase< class SendLogReactor : public ServerReadReactorBase<
backup::SendLogRequest, backup::SendLogRequest,
google::protobuf::Empty> { google::protobuf::Empty> {
enum class State { enum class State {
USER_ID = 1, USER_ID = 1,
LOG_CHUNK = 2, BACKUP_ID = 2,
LOG_HASH = 3,
LOG_CHUNK = 4,
}; };
enum class PersistenceMethod { enum class PersistenceMethod {
UNKNOWN = 0, UNKNOWN = 0,
DB = 1, DB = 1,
BLOB = 2, BLOB = 2,
}; };
State state = State::USER_ID; State state = State::USER_ID;
PersistenceMethod persistenceMethod = PersistenceMethod::UNKNOWN; PersistenceMethod persistenceMethod = PersistenceMethod::UNKNOWN;
std::string userID; std::string userID;
std::string backupID;
void storeInDatabase(const std::string &data) { std::string hash;
} // either the value itself which is a dump of a single operation (if
// `persistedInBlob` is false) or the holder to blob (if `persistedInBlob` is
void storeInBlob(const std::string &data) { // true)
} std::string value;
std::mutex reactorStateMutex;
std::condition_variable waitingForBlobClientCV;
std::mutex waitingForBlobClientCVMutex;
std::shared_ptr<reactor::BlobPutClientReactor> putReactor;
ServiceBlobClient blobClient;
void storeInDatabase();
std::string generateHolder();
std::string generateLogID();
void initializePutReactor();
public: public:
using ServerReadReactorBase<backup::SendLogRequest, google::protobuf::Empty>:: using ServerReadReactorBase<backup::SendLogRequest, google::protobuf::Empty>::
ServerReadReactorBase; ServerReadReactorBase;
std::unique_ptr<grpc::Status> std::unique_ptr<grpc::Status>
readRequest(backup::SendLogRequest request) override; readRequest(backup::SendLogRequest request) override;
void doneCallback() override; void doneCallback() override;
void terminateCallback() override;
}; };
void SendLogReactor::storeInDatabase() {
// TODO handle attachment holders
database::LogItem logItem(
this->backupID,
this->generateLogID(),
(this->persistenceMethod == PersistenceMethod::BLOB),
this->value,
{});
database::DatabaseManager::getInstance().putLogItem(logItem);
}
std::string SendLogReactor::generateHolder() {
// TODO replace mock
return generateRandomString();
}
std::string SendLogReactor::generateLogID() {
// TODO replace mock
return generateRandomString();
}
void SendLogReactor::initializePutReactor() {
if (this->value.empty() || this->hash.empty()) {
throw std::runtime_error("not enough data to initialize put reactor");
}
if (this->putReactor == nullptr) {
this->putReactor = std::make_shared<reactor::BlobPutClientReactor>(
this->value, this->hash, &this->waitingForBlobClientCV);
this->blobClient.put(this->putReactor);
}
}
std::unique_ptr<grpc::Status> std::unique_ptr<grpc::Status>
SendLogReactor::readRequest(backup::SendLogRequest request) { SendLogReactor::readRequest(backup::SendLogRequest request) {
// we make sure that the blob client's state is flushed to the main memory
// as there may be multiple threads from the pool taking over here
const std::lock_guard<std::mutex> lock(this->reactorStateMutex);
switch (this->state) { switch (this->state) {
case State::USER_ID: { case State::USER_ID: {
if (!request.has_userid()) { if (!request.has_userid()) {
throw std::runtime_error("user id expected but not received"); throw std::runtime_error("user id expected but not received");
} }
this->userID = request.userid(); this->userID = request.userid();
this->state = State::BACKUP_ID;
return nullptr;
};
case State::BACKUP_ID: {
if (!request.has_backupid()) {
throw std::runtime_error("backup id expected but not received");
}
this->backupID = request.backupid();
this->state = State::LOG_HASH;
return nullptr;
};
case State::LOG_HASH: {
if (!request.has_loghash()) {
throw std::runtime_error("log hash expected but not received");
}
this->hash = request.loghash();
this->state = State::LOG_CHUNK; this->state = State::LOG_CHUNK;
return nullptr; return nullptr;
}; };
case State::LOG_CHUNK: { case State::LOG_CHUNK: {
if (!request.has_logdata()) { if (!request.has_logdata()) {
throw std::runtime_error("log data expected but not received"); throw std::runtime_error("log data expected but not received");
} }
if (this->persistenceMethod == PersistenceMethod::DB) { std::unique_ptr<std::string> chunk =
throw std::runtime_error( std::make_unique<std::string>(std::move(*request.mutable_logdata()));
"storing multiple chunks in the database is not allowed"); if (chunk->size() == 0) {
return std::make_unique<grpc::Status>(grpc::Status::OK);
} }
std::string *chunk = request.mutable_logdata();
// decide if keep in DB or upload to blob // decide if keep in DB or upload to blob
if (chunk->size() <= LOG_DATA_SIZE_DATABASE_LIMIT) { if (chunk->size() <= LOG_DATA_SIZE_DATABASE_LIMIT) {
if (this->persistenceMethod == PersistenceMethod::UNKNOWN) { if (this->persistenceMethod == PersistenceMethod::UNKNOWN) {
this->persistenceMethod = PersistenceMethod::DB; this->persistenceMethod = PersistenceMethod::DB;
this->storeInDatabase(*chunk); this->value = std::move(*chunk);
this->storeInDatabase();
return std::make_unique<grpc::Status>(grpc::Status::OK);
} else if (this->persistenceMethod == PersistenceMethod::BLOB) { } else if (this->persistenceMethod == PersistenceMethod::BLOB) {
this->storeInBlob(*chunk); this->initializePutReactor();
this->putReactor->scheduleSendingDataChunk(std::move(chunk));
} }
throw std::runtime_error( throw std::runtime_error(
"error - invalid persistence state for chunk smaller than database " "error - invalid persistence state for chunk smaller than database "
"limit"); "limit");
} else { } else {
if (this->persistenceMethod != PersistenceMethod::UNKNOWN && if (this->persistenceMethod != PersistenceMethod::UNKNOWN &&
this->persistenceMethod != PersistenceMethod::BLOB) { this->persistenceMethod != PersistenceMethod::BLOB) {
throw std::runtime_error( throw std::runtime_error(
"error - invalid persistence state, uploading to blob should be " "error - invalid persistence state, uploading to blob should be "
"continued but it is not"); "continued but it is not");
} }
if (this->persistenceMethod == PersistenceMethod::UNKNOWN) {
this->persistenceMethod = PersistenceMethod::BLOB; this->persistenceMethod = PersistenceMethod::BLOB;
this->storeInBlob(*chunk);
} }
std::cout << "log data received " << chunk->size() << std::endl; if (this->value.empty()) {
this->value = this->generateHolder();
}
this->initializePutReactor();
this->putReactor->scheduleSendingDataChunk(std::move(chunk));
}
return nullptr; return nullptr;
}; };
} }
throw std::runtime_error("send log - invalid state"); throw std::runtime_error("send log - invalid state");
} }
void SendLogReactor::terminateCallback() {
const std::lock_guard<std::mutex> lock(this->reactorStateMutex);
if (this->persistenceMethod == PersistenceMethod::DB ||
this->putReactor == nullptr) {
return;
}
this->putReactor->scheduleSendingDataChunk(std::make_unique<std::string>(""));
std::unique_lock<std::mutex> lock2(this->waitingForBlobClientCVMutex);
this->waitingForBlobClientCV.wait(lock2);
// store in db only when we successfully upload chunks
this->storeInDatabase();
}
void SendLogReactor::doneCallback() { void SendLogReactor::doneCallback() {
const std::lock_guard<std::mutex> lock(this->reactorStateMutex);
// TODO implement // TODO implement
std::cout << "receive logs done " << this->status.error_code() << "/" std::cout << "receive logs done " << this->status.error_code() << "/"
<< this->status.error_message() << std::endl; << this->status.error_message() << std::endl;
} }
} // namespace reactor } // namespace reactor
} // namespace network } // namespace network
} // namespace comm } // namespace comm
View Options

yarn.lock

#pragma once #pragma once
#include "Constants.h" #include "Constants.h"
#include "ServerReadReactorBase.h" #include "ServerReadReactorBase.h"
#include "ServiceBlobClient.h"
#include "Tools.h"
#include "../_generated/backup.grpc.pb.h" #include "../_generated/backup.grpc.pb.h"
#include "../_generated/backup.pb.h" #include "../_generated/backup.pb.h"
#include <iostream> #include <iostream>
#include <memory> #include <memory>
#include <string> #include <string>
namespace comm { namespace comm {
namespace network { namespace network {
namespace reactor { namespace reactor {
class SendLogReactor : public ServerReadReactorBase< class SendLogReactor : public ServerReadReactorBase<
backup::SendLogRequest, backup::SendLogRequest,
google::protobuf::Empty> { google::protobuf::Empty> {
enum class State { enum class State {
USER_ID = 1, USER_ID = 1,
LOG_CHUNK = 2, BACKUP_ID = 2,
LOG_HASH = 3,
LOG_CHUNK = 4,
}; };
enum class PersistenceMethod { enum class PersistenceMethod {
UNKNOWN = 0, UNKNOWN = 0,
DB = 1, DB = 1,
BLOB = 2, BLOB = 2,
}; };
State state = State::USER_ID; State state = State::USER_ID;
PersistenceMethod persistenceMethod = PersistenceMethod::UNKNOWN; PersistenceMethod persistenceMethod = PersistenceMethod::UNKNOWN;
std::string userID; std::string userID;
std::string backupID;
void storeInDatabase(const std::string &data) { std::string hash;
} // either the value itself which is a dump of a single operation (if
// `persistedInBlob` is false) or the holder to blob (if `persistedInBlob` is
void storeInBlob(const std::string &data) { // true)
} std::string value;
std::mutex reactorStateMutex;
std::condition_variable waitingForBlobClientCV;
std::mutex waitingForBlobClientCVMutex;
std::shared_ptr<reactor::BlobPutClientReactor> putReactor;
ServiceBlobClient blobClient;
void storeInDatabase();
std::string generateHolder();
std::string generateLogID();
void initializePutReactor();
public: public:
using ServerReadReactorBase<backup::SendLogRequest, google::protobuf::Empty>:: using ServerReadReactorBase<backup::SendLogRequest, google::protobuf::Empty>::
ServerReadReactorBase; ServerReadReactorBase;
std::unique_ptr<grpc::Status> std::unique_ptr<grpc::Status>
readRequest(backup::SendLogRequest request) override; readRequest(backup::SendLogRequest request) override;
void doneCallback() override; void doneCallback() override;
void terminateCallback() override;
}; };
void SendLogReactor::storeInDatabase() {
// TODO handle attachment holders
database::LogItem logItem(
this->backupID,
this->generateLogID(),
(this->persistenceMethod == PersistenceMethod::BLOB),
this->value,
{});
database::DatabaseManager::getInstance().putLogItem(logItem);
}
std::string SendLogReactor::generateHolder() {
// TODO replace mock
return generateRandomString();
}
std::string SendLogReactor::generateLogID() {
// TODO replace mock
return generateRandomString();
}
void SendLogReactor::initializePutReactor() {
if (this->value.empty() || this->hash.empty()) {
throw std::runtime_error("not enough data to initialize put reactor");
}
if (this->putReactor == nullptr) {
this->putReactor = std::make_shared<reactor::BlobPutClientReactor>(
this->value, this->hash, &this->waitingForBlobClientCV);
this->blobClient.put(this->putReactor);
}
}
std::unique_ptr<grpc::Status> std::unique_ptr<grpc::Status>
SendLogReactor::readRequest(backup::SendLogRequest request) { SendLogReactor::readRequest(backup::SendLogRequest request) {
// we make sure that the blob client's state is flushed to the main memory
// as there may be multiple threads from the pool taking over here
const std::lock_guard<std::mutex> lock(this->reactorStateMutex);
switch (this->state) { switch (this->state) {
case State::USER_ID: { case State::USER_ID: {
if (!request.has_userid()) { if (!request.has_userid()) {
throw std::runtime_error("user id expected but not received"); throw std::runtime_error("user id expected but not received");
} }
this->userID = request.userid(); this->userID = request.userid();
this->state = State::BACKUP_ID;
return nullptr;
};
case State::BACKUP_ID: {
if (!request.has_backupid()) {
throw std::runtime_error("backup id expected but not received");
}
this->backupID = request.backupid();
this->state = State::LOG_HASH;
return nullptr;
};
case State::LOG_HASH: {
if (!request.has_loghash()) {
throw std::runtime_error("log hash expected but not received");
}
this->hash = request.loghash();
this->state = State::LOG_CHUNK; this->state = State::LOG_CHUNK;
return nullptr; return nullptr;
}; };
case State::LOG_CHUNK: { case State::LOG_CHUNK: {
if (!request.has_logdata()) { if (!request.has_logdata()) {
throw std::runtime_error("log data expected but not received"); throw std::runtime_error("log data expected but not received");
} }
if (this->persistenceMethod == PersistenceMethod::DB) { std::unique_ptr<std::string> chunk =
throw std::runtime_error( std::make_unique<std::string>(std::move(*request.mutable_logdata()));
"storing multiple chunks in the database is not allowed"); if (chunk->size() == 0) {
return std::make_unique<grpc::Status>(grpc::Status::OK);
} }
std::string *chunk = request.mutable_logdata();
// decide if keep in DB or upload to blob // decide if keep in DB or upload to blob
if (chunk->size() <= LOG_DATA_SIZE_DATABASE_LIMIT) { if (chunk->size() <= LOG_DATA_SIZE_DATABASE_LIMIT) {
if (this->persistenceMethod == PersistenceMethod::UNKNOWN) { if (this->persistenceMethod == PersistenceMethod::UNKNOWN) {
this->persistenceMethod = PersistenceMethod::DB; this->persistenceMethod = PersistenceMethod::DB;
this->storeInDatabase(*chunk); this->value = std::move(*chunk);
this->storeInDatabase();
return std::make_unique<grpc::Status>(grpc::Status::OK);
} else if (this->persistenceMethod == PersistenceMethod::BLOB) { } else if (this->persistenceMethod == PersistenceMethod::BLOB) {
this->storeInBlob(*chunk); this->initializePutReactor();
this->putReactor->scheduleSendingDataChunk(std::move(chunk));
} }
throw std::runtime_error( throw std::runtime_error(
"error - invalid persistence state for chunk smaller than database " "error - invalid persistence state for chunk smaller than database "
"limit"); "limit");
} else { } else {
if (this->persistenceMethod != PersistenceMethod::UNKNOWN && if (this->persistenceMethod != PersistenceMethod::UNKNOWN &&
this->persistenceMethod != PersistenceMethod::BLOB) { this->persistenceMethod != PersistenceMethod::BLOB) {
throw std::runtime_error( throw std::runtime_error(
"error - invalid persistence state, uploading to blob should be " "error - invalid persistence state, uploading to blob should be "
"continued but it is not"); "continued but it is not");
} }
if (this->persistenceMethod == PersistenceMethod::UNKNOWN) {
this->persistenceMethod = PersistenceMethod::BLOB; this->persistenceMethod = PersistenceMethod::BLOB;
this->storeInBlob(*chunk);
} }
std::cout << "log data received " << chunk->size() << std::endl; if (this->value.empty()) {
this->value = this->generateHolder();
}
this->initializePutReactor();
this->putReactor->scheduleSendingDataChunk(std::move(chunk));
}
return nullptr; return nullptr;
}; };
} }
throw std::runtime_error("send log - invalid state"); throw std::runtime_error("send log - invalid state");
} }
void SendLogReactor::terminateCallback() {
const std::lock_guard<std::mutex> lock(this->reactorStateMutex);
if (this->persistenceMethod == PersistenceMethod::DB ||
this->putReactor == nullptr) {
return;
}
this->putReactor->scheduleSendingDataChunk(std::make_unique<std::string>(""));
std::unique_lock<std::mutex> lock2(this->waitingForBlobClientCVMutex);
this->waitingForBlobClientCV.wait(lock2);
// store in db only when we successfully upload chunks
this->storeInDatabase();
}
void SendLogReactor::doneCallback() { void SendLogReactor::doneCallback() {
const std::lock_guard<std::mutex> lock(this->reactorStateMutex);
// TODO implement // TODO implement
std::cout << "receive logs done " << this->status.error_code() << "/" std::cout << "receive logs done " << this->status.error_code() << "/"
<< this->status.error_message() << std::endl; << this->status.error_message() << std::endl;
} }
} // namespace reactor } // namespace reactor
} // namespace network } // namespace network
} // namespace comm } // namespace comm