Page MenuHomePhabricator
Differential D14486

[native] Script to bump native version
ClosedPublic
Actions

Authored by ashoat on Thu, Mar 20, 7:24 PM.
Tags
None
Referenced Files
F5086244: D14486.id.diff
Sat, Mar 29, 7:06 PM
F5082330: D14486.id47514.diff
Sat, Mar 29, 9:01 AM
F5081989: D14486.id47515.diff
Sat, Mar 29, 7:25 AM
F5081127: D14486.id47519.diff
Sat, Mar 29, 4:59 AM
Unknown Object (File)
Fri, Mar 28, 6:05 PM
Unknown Object (File)
Fri, Mar 28, 5:23 PM
Unknown Object (File)
Wed, Mar 26, 1:56 PM
Unknown Object (File)
Wed, Mar 26, 10:15 AM
View All 50 Files
Subscribers
None

Details

Reviewers
tomek
angelika
Commits
rCOMM06bd90759920: [native] Script to bump native version
Summary

Claude helped generate this. Will save me some time during release processes.

Test Plan

Ran the script and it worked!

Diff Detail

Repository
rCOMM Comm
Branch
ashoat/versionBumpScript
Lint
No Lint Coverage
Unit
No Test Coverage

Event Timeline

ashoat created this revision.Thu, Mar 20, 7:24 PM
ashoat updated this revision to Diff 47512.Thu, Mar 20, 7:28 PM

Fix Flow

ashoat updated this revision to Diff 47513.Thu, Mar 20, 7:30 PM

Accidentally had bumped version in version.js

ashoat updated this revision to Diff 47514.Thu, Mar 20, 7:32 PM

Minor: update comment

Harbormaster failed remote builds in B33801: Diff 47511!Thu, Mar 20, 7:33 PM
Harbormaster failed remote builds in B33802: Diff 47512!Thu, Mar 20, 7:42 PM
Harbormaster failed remote builds in B33803: Diff 47513!
Harbormaster returned this revision to the author for changes because remote builds failed.Thu, Mar 20, 7:45 PM
Harbormaster failed remote builds in B33804: Diff 47514!
ashoat updated this revision to Diff 47515.Thu, Mar 20, 8:21 PM

Avoid setting type: "module" in native/package.json as it breaks some scripts

Harbormaster returned this revision to the author for changes because remote builds failed.Thu, Mar 20, 8:30 PM
Harbormaster failed remote builds in B33805: Diff 47515!
ashoat updated this revision to Diff 47516.Thu, Mar 20, 8:48 PM

Add .mjs files to .flowconfig

Harbormaster returned this revision to the author for changes because remote builds failed.Thu, Mar 20, 8:56 PM
Harbormaster failed remote builds in B33806: Diff 47516!
ashoat added inline comments.Thu, Mar 20, 9:03 PM
native/scripts/update-mobile-version.mjs
5
Harbormaster completed remote builds in B33806: Diff 47516.Thu, Mar 20, 9:08 PM
ashoat requested review of this revision.Thu, Mar 20, 9:08 PM
angelika accepted this revision.Fri, Mar 21, 12:32 AM

LGTM, but:

  • don't we need to document it somewhere in some README?
  • as far as I understand to update the version you bump the version in version.mjs first, then run the script, can't we automate the first step too?
  • you can also automate making commits too later?
This revision is now accepted and ready to land.Fri, Mar 21, 12:32 AM
tomek accepted this revision.Fri, Mar 21, 4:20 AM
ashoat added a comment.Fri, Mar 21, 3:59 PM
  • don't we need to document it somewhere in some README?

No, I don't think so. We don't really document the release process in the README.

  • as far as I understand to update the version you bump the version in version.mjs first, then run the script, can't we automate the first step too?

Yeah, and I think this could be done for keyserver and web too. But I'm starting with this script because it's currently the most annoying / rote part of the process for me. Hope to make further improvements at a later point.

  • you can also automate making commits too later?

Yeah agree we could improve the process further.

ashoat updated this revision to Diff 47518.Fri, Mar 21, 3:59 PM

Update comment

ashoat updated this revision to Diff 47519.Fri, Mar 21, 4:01 PM

One more comment update

Harbormaster completed remote builds in B33808: Diff 47518.Fri, Mar 21, 4:18 PM
Harbormaster completed remote builds in B33809: Diff 47519.
Closed by commit rCOMM06bd90759920: [native] Script to bump native version (authored by ashoat). · Explain WhyFri, Mar 21, 4:20 PM
This revision was automatically updated to reflect the committed changes.
ashoat added a commit: rCOMM06bd90759920: [native] Script to bump native version.

Revision Contents
Changeset List

PathSize
native/
1 line
cpp/
CommonCpp/
NativeModules/
1 line
3 lines
redux/
3 lines
scripts/
147 lines
4 lines

Diff 47516

View Options

native/.flowconfig

Show First 20 Lines • Show All 65 Lines • ▼ Show 20 Lines case State::DATA_HASH: {
} }
response->set_backupid(this->backupID); response->set_backupid(this->backupID);
this->holder = tools::generateHolder(this->dataHash, this->backupID); this->holder = tools::generateHolder(this->dataHash, this->backupID);
put_client_initialize_cxx(this->holder.c_str()); put_client_initialize_cxx(this->holder.c_str());
put_client_write_cxx( put_client_write_cxx(
this->holder.c_str(), this->holder.c_str(),
tools::getBlobPutField(blob::PutRequest::DataCase::kHolder), tools::getBlobPutField(blob::PutRequest::DataCase::kHolder),
this->holder.c_str()); this->holder.c_str());
put_client_blocking_read_cxx( put_client_blocking_read_cxx(this->holder.c_str());
this->holder.c_str()); // todo this should be avoided
// (blocking); we should be able to
// ignore responses; we probably want to
// delegate performing ops to separate
// threads in the base reactors
put_client_write_cxx( put_client_write_cxx(
this->holder.c_str(), this->holder.c_str(),
tools::getBlobPutField(blob::PutRequest::DataCase::kBlobHash), tools::getBlobPutField(blob::PutRequest::DataCase::kBlobHash),
this->dataHash.c_str()); this->dataHash.c_str());
rust::String responseStr = put_client_blocking_read_cxx( rust::String responseStr =
this->holder.c_str()); // todo this should be avoided put_client_blocking_read_cxx(this->holder.c_str());
// (blocking); we should be able to
// ignore responses; we probably
// want to delegate performing ops
// to separate threads in the base
// reactors
// data exists? // data exists?
if ((bool)tools::charPtrToInt(responseStr.c_str())) { if ((bool)tools::charPtrToInt(responseStr.c_str())) {
return std::make_unique<ServerBidiReactorStatus>( return std::make_unique<ServerBidiReactorStatus>(
grpc::Status::OK, true); grpc::Status::OK, true);
} }
return nullptr; return nullptr;
} }
case State::DATA_CHUNKS: { case State::DATA_CHUNKS: {
if (request.mutable_newcompactionchunk()->empty()) { if (request.mutable_newcompactionchunk()->empty()) {
return std::make_unique<ServerBidiReactorStatus>(grpc::Status::OK); return std::make_unique<ServerBidiReactorStatus>(grpc::Status::OK);
} }
put_client_write_cxx( put_client_write_cxx(
this->holder.c_str(), this->holder.c_str(),
tools::getBlobPutField(blob::PutRequest::DataCase::kDataChunk), tools::getBlobPutField(blob::PutRequest::DataCase::kDataChunk),
std::string(std::move(*request.mutable_newcompactionchunk())) std::string(std::move(*request.mutable_newcompactionchunk()))
.c_str()); .c_str());
put_client_blocking_read_cxx( put_client_blocking_read_cxx(this->holder.c_str());
this->holder.c_str()); // todo this should be avoided
// (blocking); we should be able to
// ignore responses; we probably want to
// delegate performing ops to separate
// threads in the base reactors
return nullptr; return nullptr;
} }
} }
throw std::runtime_error("new backup - invalid state"); throw std::runtime_error("new backup - invalid state");
} }
void CreateNewBackupReactor::terminateCallback() { void CreateNewBackupReactor::terminateCallback() {
Show All 18 Lines
View Options

native/cpp/CommonCpp/NativeModules/CommCoreModule.h

Show First 20 Lines • Show All 65 Lines • ▼ Show 20 Lines case State::DATA_HASH: {
} }
response->set_backupid(this->backupID); response->set_backupid(this->backupID);
this->holder = tools::generateHolder(this->dataHash, this->backupID); this->holder = tools::generateHolder(this->dataHash, this->backupID);
put_client_initialize_cxx(this->holder.c_str()); put_client_initialize_cxx(this->holder.c_str());
put_client_write_cxx( put_client_write_cxx(
this->holder.c_str(), this->holder.c_str(),
tools::getBlobPutField(blob::PutRequest::DataCase::kHolder), tools::getBlobPutField(blob::PutRequest::DataCase::kHolder),
this->holder.c_str()); this->holder.c_str());
put_client_blocking_read_cxx( put_client_blocking_read_cxx(this->holder.c_str());
this->holder.c_str()); // todo this should be avoided
// (blocking); we should be able to
// ignore responses; we probably want to
// delegate performing ops to separate
// threads in the base reactors
put_client_write_cxx( put_client_write_cxx(
this->holder.c_str(), this->holder.c_str(),
tools::getBlobPutField(blob::PutRequest::DataCase::kBlobHash), tools::getBlobPutField(blob::PutRequest::DataCase::kBlobHash),
this->dataHash.c_str()); this->dataHash.c_str());
rust::String responseStr = put_client_blocking_read_cxx( rust::String responseStr =
this->holder.c_str()); // todo this should be avoided put_client_blocking_read_cxx(this->holder.c_str());
// (blocking); we should be able to
// ignore responses; we probably
// want to delegate performing ops
// to separate threads in the base
// reactors
// data exists? // data exists?
if ((bool)tools::charPtrToInt(responseStr.c_str())) { if ((bool)tools::charPtrToInt(responseStr.c_str())) {
return std::make_unique<ServerBidiReactorStatus>( return std::make_unique<ServerBidiReactorStatus>(
grpc::Status::OK, true); grpc::Status::OK, true);
} }
return nullptr; return nullptr;
} }
case State::DATA_CHUNKS: { case State::DATA_CHUNKS: {
if (request.mutable_newcompactionchunk()->empty()) { if (request.mutable_newcompactionchunk()->empty()) {
return std::make_unique<ServerBidiReactorStatus>(grpc::Status::OK); return std::make_unique<ServerBidiReactorStatus>(grpc::Status::OK);
} }
put_client_write_cxx( put_client_write_cxx(
this->holder.c_str(), this->holder.c_str(),
tools::getBlobPutField(blob::PutRequest::DataCase::kDataChunk), tools::getBlobPutField(blob::PutRequest::DataCase::kDataChunk),
std::string(std::move(*request.mutable_newcompactionchunk())) std::string(std::move(*request.mutable_newcompactionchunk()))
.c_str()); .c_str());
put_client_blocking_read_cxx( put_client_blocking_read_cxx(this->holder.c_str());
this->holder.c_str()); // todo this should be avoided
// (blocking); we should be able to
// ignore responses; we probably want to
// delegate performing ops to separate
// threads in the base reactors
return nullptr; return nullptr;
} }
} }
throw std::runtime_error("new backup - invalid state"); throw std::runtime_error("new backup - invalid state");
} }
void CreateNewBackupReactor::terminateCallback() { void CreateNewBackupReactor::terminateCallback() {
Show All 18 Lines
View Options

native/package.json

Show First 20 Lines • Show All 65 Lines • ▼ Show 20 Lines case State::DATA_HASH: {
} }
response->set_backupid(this->backupID); response->set_backupid(this->backupID);
this->holder = tools::generateHolder(this->dataHash, this->backupID); this->holder = tools::generateHolder(this->dataHash, this->backupID);
put_client_initialize_cxx(this->holder.c_str()); put_client_initialize_cxx(this->holder.c_str());
put_client_write_cxx( put_client_write_cxx(
this->holder.c_str(), this->holder.c_str(),
tools::getBlobPutField(blob::PutRequest::DataCase::kHolder), tools::getBlobPutField(blob::PutRequest::DataCase::kHolder),
this->holder.c_str()); this->holder.c_str());
put_client_blocking_read_cxx( put_client_blocking_read_cxx(this->holder.c_str());
this->holder.c_str()); // todo this should be avoided
// (blocking); we should be able to
// ignore responses; we probably want to
// delegate performing ops to separate
// threads in the base reactors
put_client_write_cxx( put_client_write_cxx(
this->holder.c_str(), this->holder.c_str(),
tools::getBlobPutField(blob::PutRequest::DataCase::kBlobHash), tools::getBlobPutField(blob::PutRequest::DataCase::kBlobHash),
this->dataHash.c_str()); this->dataHash.c_str());
rust::String responseStr = put_client_blocking_read_cxx( rust::String responseStr =
this->holder.c_str()); // todo this should be avoided put_client_blocking_read_cxx(this->holder.c_str());
// (blocking); we should be able to
// ignore responses; we probably
// want to delegate performing ops
// to separate threads in the base
// reactors
// data exists? // data exists?
if ((bool)tools::charPtrToInt(responseStr.c_str())) { if ((bool)tools::charPtrToInt(responseStr.c_str())) {
return std::make_unique<ServerBidiReactorStatus>( return std::make_unique<ServerBidiReactorStatus>(
grpc::Status::OK, true); grpc::Status::OK, true);
} }
return nullptr; return nullptr;
} }
case State::DATA_CHUNKS: { case State::DATA_CHUNKS: {
if (request.mutable_newcompactionchunk()->empty()) { if (request.mutable_newcompactionchunk()->empty()) {
return std::make_unique<ServerBidiReactorStatus>(grpc::Status::OK); return std::make_unique<ServerBidiReactorStatus>(grpc::Status::OK);
} }
put_client_write_cxx( put_client_write_cxx(
this->holder.c_str(), this->holder.c_str(),
tools::getBlobPutField(blob::PutRequest::DataCase::kDataChunk), tools::getBlobPutField(blob::PutRequest::DataCase::kDataChunk),
std::string(std::move(*request.mutable_newcompactionchunk())) std::string(std::move(*request.mutable_newcompactionchunk()))
.c_str()); .c_str());
put_client_blocking_read_cxx( put_client_blocking_read_cxx(this->holder.c_str());
this->holder.c_str()); // todo this should be avoided
// (blocking); we should be able to
// ignore responses; we probably want to
// delegate performing ops to separate
// threads in the base reactors
return nullptr; return nullptr;
} }
} }
throw std::runtime_error("new backup - invalid state"); throw std::runtime_error("new backup - invalid state");
} }
void CreateNewBackupReactor::terminateCallback() { void CreateNewBackupReactor::terminateCallback() {
Show All 18 Lines
View Options

native/redux/persist.js

Show First 20 Lines • Show All 65 Lines • ▼ Show 20 Lines case State::DATA_HASH: {
} }
response->set_backupid(this->backupID); response->set_backupid(this->backupID);
this->holder = tools::generateHolder(this->dataHash, this->backupID); this->holder = tools::generateHolder(this->dataHash, this->backupID);
put_client_initialize_cxx(this->holder.c_str()); put_client_initialize_cxx(this->holder.c_str());
put_client_write_cxx( put_client_write_cxx(
this->holder.c_str(), this->holder.c_str(),
tools::getBlobPutField(blob::PutRequest::DataCase::kHolder), tools::getBlobPutField(blob::PutRequest::DataCase::kHolder),
this->holder.c_str()); this->holder.c_str());
put_client_blocking_read_cxx( put_client_blocking_read_cxx(this->holder.c_str());
this->holder.c_str()); // todo this should be avoided
// (blocking); we should be able to
// ignore responses; we probably want to
// delegate performing ops to separate
// threads in the base reactors
put_client_write_cxx( put_client_write_cxx(
this->holder.c_str(), this->holder.c_str(),
tools::getBlobPutField(blob::PutRequest::DataCase::kBlobHash), tools::getBlobPutField(blob::PutRequest::DataCase::kBlobHash),
this->dataHash.c_str()); this->dataHash.c_str());
rust::String responseStr = put_client_blocking_read_cxx( rust::String responseStr =
this->holder.c_str()); // todo this should be avoided put_client_blocking_read_cxx(this->holder.c_str());
// (blocking); we should be able to
// ignore responses; we probably
// want to delegate performing ops
// to separate threads in the base
// reactors
// data exists? // data exists?
if ((bool)tools::charPtrToInt(responseStr.c_str())) { if ((bool)tools::charPtrToInt(responseStr.c_str())) {
return std::make_unique<ServerBidiReactorStatus>( return std::make_unique<ServerBidiReactorStatus>(
grpc::Status::OK, true); grpc::Status::OK, true);
} }
return nullptr; return nullptr;
} }
case State::DATA_CHUNKS: { case State::DATA_CHUNKS: {
if (request.mutable_newcompactionchunk()->empty()) { if (request.mutable_newcompactionchunk()->empty()) {
return std::make_unique<ServerBidiReactorStatus>(grpc::Status::OK); return std::make_unique<ServerBidiReactorStatus>(grpc::Status::OK);
} }
put_client_write_cxx( put_client_write_cxx(
this->holder.c_str(), this->holder.c_str(),
tools::getBlobPutField(blob::PutRequest::DataCase::kDataChunk), tools::getBlobPutField(blob::PutRequest::DataCase::kDataChunk),
std::string(std::move(*request.mutable_newcompactionchunk())) std::string(std::move(*request.mutable_newcompactionchunk()))
.c_str()); .c_str());
put_client_blocking_read_cxx( put_client_blocking_read_cxx(this->holder.c_str());
this->holder.c_str()); // todo this should be avoided
// (blocking); we should be able to
// ignore responses; we probably want to
// delegate performing ops to separate
// threads in the base reactors
return nullptr; return nullptr;
} }
} }
throw std::runtime_error("new backup - invalid state"); throw std::runtime_error("new backup - invalid state");
} }
void CreateNewBackupReactor::terminateCallback() { void CreateNewBackupReactor::terminateCallback() {
Show All 18 Lines
View Options

native/scripts/update-mobile-version.mjs

Show First 20 Lines • Show All 65 Lines • ▼ Show 20 Lines case State::DATA_HASH: {
} }
response->set_backupid(this->backupID); response->set_backupid(this->backupID);
this->holder = tools::generateHolder(this->dataHash, this->backupID); this->holder = tools::generateHolder(this->dataHash, this->backupID);
put_client_initialize_cxx(this->holder.c_str()); put_client_initialize_cxx(this->holder.c_str());
put_client_write_cxx( put_client_write_cxx(
this->holder.c_str(), this->holder.c_str(),
tools::getBlobPutField(blob::PutRequest::DataCase::kHolder), tools::getBlobPutField(blob::PutRequest::DataCase::kHolder),
this->holder.c_str()); this->holder.c_str());
put_client_blocking_read_cxx( put_client_blocking_read_cxx(this->holder.c_str());
this->holder.c_str()); // todo this should be avoided
// (blocking); we should be able to
// ignore responses; we probably want to
// delegate performing ops to separate
// threads in the base reactors
put_client_write_cxx( put_client_write_cxx(
this->holder.c_str(), this->holder.c_str(),
tools::getBlobPutField(blob::PutRequest::DataCase::kBlobHash), tools::getBlobPutField(blob::PutRequest::DataCase::kBlobHash),
this->dataHash.c_str()); this->dataHash.c_str());
rust::String responseStr = put_client_blocking_read_cxx( rust::String responseStr =
this->holder.c_str()); // todo this should be avoided put_client_blocking_read_cxx(this->holder.c_str());
// (blocking); we should be able to
// ignore responses; we probably
// want to delegate performing ops
// to separate threads in the base
// reactors
// data exists? // data exists?
if ((bool)tools::charPtrToInt(responseStr.c_str())) { if ((bool)tools::charPtrToInt(responseStr.c_str())) {
return std::make_unique<ServerBidiReactorStatus>( return std::make_unique<ServerBidiReactorStatus>(
grpc::Status::OK, true); grpc::Status::OK, true);
} }
return nullptr; return nullptr;
} }
case State::DATA_CHUNKS: { case State::DATA_CHUNKS: {
if (request.mutable_newcompactionchunk()->empty()) { if (request.mutable_newcompactionchunk()->empty()) {
return std::make_unique<ServerBidiReactorStatus>(grpc::Status::OK); return std::make_unique<ServerBidiReactorStatus>(grpc::Status::OK);
} }
put_client_write_cxx( put_client_write_cxx(
this->holder.c_str(), this->holder.c_str(),
tools::getBlobPutField(blob::PutRequest::DataCase::kDataChunk), tools::getBlobPutField(blob::PutRequest::DataCase::kDataChunk),
std::string(std::move(*request.mutable_newcompactionchunk())) std::string(std::move(*request.mutable_newcompactionchunk()))
.c_str()); .c_str());
put_client_blocking_read_cxx( put_client_blocking_read_cxx(this->holder.c_str());
this->holder.c_str()); // todo this should be avoided
// (blocking); we should be able to
// ignore responses; we probably want to
// delegate performing ops to separate
// threads in the base reactors
return nullptr; return nullptr;
} }
} }
throw std::runtime_error("new backup - invalid state"); throw std::runtime_error("new backup - invalid state");
} }
void CreateNewBackupReactor::terminateCallback() { void CreateNewBackupReactor::terminateCallback() {
Show All 18 Lines
View Options

native/version.mjs

Show First 20 Lines • Show All 65 Lines • ▼ Show 20 Lines case State::DATA_HASH: {
} }
response->set_backupid(this->backupID); response->set_backupid(this->backupID);
this->holder = tools::generateHolder(this->dataHash, this->backupID); this->holder = tools::generateHolder(this->dataHash, this->backupID);
put_client_initialize_cxx(this->holder.c_str()); put_client_initialize_cxx(this->holder.c_str());
put_client_write_cxx( put_client_write_cxx(
this->holder.c_str(), this->holder.c_str(),
tools::getBlobPutField(blob::PutRequest::DataCase::kHolder), tools::getBlobPutField(blob::PutRequest::DataCase::kHolder),
this->holder.c_str()); this->holder.c_str());
put_client_blocking_read_cxx( put_client_blocking_read_cxx(this->holder.c_str());
this->holder.c_str()); // todo this should be avoided
// (blocking); we should be able to
// ignore responses; we probably want to
// delegate performing ops to separate
// threads in the base reactors
put_client_write_cxx( put_client_write_cxx(
this->holder.c_str(), this->holder.c_str(),
tools::getBlobPutField(blob::PutRequest::DataCase::kBlobHash), tools::getBlobPutField(blob::PutRequest::DataCase::kBlobHash),
this->dataHash.c_str()); this->dataHash.c_str());
rust::String responseStr = put_client_blocking_read_cxx( rust::String responseStr =
this->holder.c_str()); // todo this should be avoided put_client_blocking_read_cxx(this->holder.c_str());
// (blocking); we should be able to
// ignore responses; we probably
// want to delegate performing ops
// to separate threads in the base
// reactors
// data exists? // data exists?
if ((bool)tools::charPtrToInt(responseStr.c_str())) { if ((bool)tools::charPtrToInt(responseStr.c_str())) {
return std::make_unique<ServerBidiReactorStatus>( return std::make_unique<ServerBidiReactorStatus>(
grpc::Status::OK, true); grpc::Status::OK, true);
} }
return nullptr; return nullptr;
} }
case State::DATA_CHUNKS: { case State::DATA_CHUNKS: {
if (request.mutable_newcompactionchunk()->empty()) { if (request.mutable_newcompactionchunk()->empty()) {
return std::make_unique<ServerBidiReactorStatus>(grpc::Status::OK); return std::make_unique<ServerBidiReactorStatus>(grpc::Status::OK);
} }
put_client_write_cxx( put_client_write_cxx(
this->holder.c_str(), this->holder.c_str(),
tools::getBlobPutField(blob::PutRequest::DataCase::kDataChunk), tools::getBlobPutField(blob::PutRequest::DataCase::kDataChunk),
std::string(std::move(*request.mutable_newcompactionchunk())) std::string(std::move(*request.mutable_newcompactionchunk()))
.c_str()); .c_str());
put_client_blocking_read_cxx( put_client_blocking_read_cxx(this->holder.c_str());
this->holder.c_str()); // todo this should be avoided
// (blocking); we should be able to
// ignore responses; we probably want to
// delegate performing ops to separate
// threads in the base reactors
return nullptr; return nullptr;
} }
} }
throw std::runtime_error("new backup - invalid state"); throw std::runtime_error("new backup - invalid state");
} }
void CreateNewBackupReactor::terminateCallback() { void CreateNewBackupReactor::terminateCallback() {
Show All 18 Lines