Page MenuHomePhabricator
Differential D14437

[terraform] add OpenSearch error logs
ClosedPublic
Actions

Authored by kamil on Mar 13 2025, 4:56 AM.
Tags
None
Referenced Files
Unknown Object (File)
Mon, Apr 21, 3:44 AM
Unknown Object (File)
Sat, Apr 19, 2:25 AM
Unknown Object (File)
Fri, Apr 18, 9:15 PM
Unknown Object (File)
Fri, Apr 18, 6:47 PM
Unknown Object (File)
Fri, Apr 18, 5:31 PM
Unknown Object (File)
Thu, Apr 17, 9:41 PM
Unknown Object (File)
Sun, Apr 13, 2:51 PM
Unknown Object (File)
Sun, Apr 6, 8:31 AM
View All 24 Files
Subscribers
ashoat

Details

Reviewers
tomek
bartek
Commits
rCOMMe7693ea6d559: [terraform] add OpenSearch error logs
Summary

ENG-10371.

Test Plan

terraform plan shows no changes

Diff Detail

Repository
rCOMM Comm
Branch
add-logs
Lint
No Lint Coverage
Unit
No Test Coverage

Event Timeline

kamil created this revision.Mar 13 2025, 4:56 AM
kamil held this revision as a draft.
Herald added a subscriber: ashoat. · View Herald TranscriptMar 13 2025, 4:56 AM
kamil retitled this revision from [terraform] add OpenSearch logs to [terraform] add OpenSearch error logs.Mar 13 2025, 5:07 AM
kamil edited the test plan for this revision. (Show Details)
kamil published this revision for review.Mar 13 2025, 5:13 AM
tomek accepted this revision.Mar 13 2025, 5:16 AM
This revision is now accepted and ready to land.Mar 13 2025, 5:16 AM
This revision was landed with ongoing or failed builds.Mar 13 2025, 5:22 AM
Closed by commit rCOMMe7693ea6d559: [terraform] add OpenSearch error logs (authored by kamil). · Explain Why
This revision was automatically updated to reflect the committed changes.
kamil added a commit: rCOMMe7693ea6d559: [terraform] add OpenSearch error logs.
Harbormaster completed remote builds in B33710: Diff 47389.Mar 13 2025, 8:05 AM

Revision Contents
Changeset List

PathSize
services/
terraform/
modules/
shared/
6 lines
5 lines
remote/
1 line

Diff 47389

View Options

services/terraform/modules/shared/opensearch.tf

Show All 13 Lines
} }
jsi::Value CommRustModule::generateNonce(jsi::Runtime &rt) { jsi::Value CommRustModule::generateNonce(jsi::Runtime &rt) {
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityGenerateNonce(currentID); identityGenerateNonce(currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
}; };
if (!error.empty()) { if (!error.empty()) {
this->jsInvoker_->invokeAsync( this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); }); [error, promise]() { promise->reject(error); });
} }
Show All 25 Linesjsi::Value CommRustModule::registerUser(
auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt); auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt);
auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt); auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityRegisterUser( identityRegisterUser(
usernameRust, usernameRust,
passwordRust, passwordRust,
keyPayloadRust, keyPayloadRust,
keyPayloadSignatureRust, keyPayloadSignatureRust,
contentPrekeyRust, contentPrekeyRust,
contentPrekeySignatureRust, contentPrekeySignatureRust,
notifPrekeyRust, notifPrekeyRust,
Show All 36 Linesjsi::Value CommRustModule::loginPasswordUser(
auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt); auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt);
auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt); auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityLoginPasswordUser( identityLoginPasswordUser(
usernameRust, usernameRust,
passwordRust, passwordRust,
keyPayloadRust, keyPayloadRust,
keyPayloadSignatureRust, keyPayloadSignatureRust,
contentPrekeyRust, contentPrekeyRust,
contentPrekeySignatureRust, contentPrekeySignatureRust,
notifPrekeyRust, notifPrekeyRust,
Show All 38 Linesjsi::Value CommRustModule::loginWalletUser(
auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt); auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
auto socialProofRust = jsiStringToRustString(socialProof, rt); auto socialProofRust = jsiStringToRustString(socialProof, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityLoginWalletUser( identityLoginWalletUser(
siweMessageRust, siweMessageRust,
siweSignatureRust, siweSignatureRust,
keyPayloadRust, keyPayloadRust,
keyPayloadSignatureRust, keyPayloadSignatureRust,
contentPrekeyRust, contentPrekeyRust,
contentPrekeySignatureRust, contentPrekeySignatureRust,
notifPrekeyRust, notifPrekeyRust,
Show All 23 Linesjsi::Value CommRustModule::updatePassword(
auto accessTokenRust = jsiStringToRustString(accessToken, rt); auto accessTokenRust = jsiStringToRustString(accessToken, rt);
auto passwordRust = jsiStringToRustString(password, rt); auto passwordRust = jsiStringToRustString(password, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityUpdateUserPassword( identityUpdateUserPassword(
userIDRust, userIDRust,
deviceIDRust, deviceIDRust,
accessTokenRust, accessTokenRust,
passwordRust, passwordRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
Show All 14 Linesjsi::Value CommRustModule::deleteUser(
auto deviceIDRust = jsiStringToRustString(deviceID, rt); auto deviceIDRust = jsiStringToRustString(deviceID, rt);
auto accessTokenRust = jsiStringToRustString(accessToken, rt); auto accessTokenRust = jsiStringToRustString(accessToken, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityDeleteUser( identityDeleteUser(
userIDRust, deviceIDRust, accessTokenRust, currentID); userIDRust, deviceIDRust, accessTokenRust, currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
}; };
if (!error.empty()) { if (!error.empty()) {
this->jsInvoker_->invokeAsync( this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); }); [error, promise]() { promise->reject(error); });
Show All 12 Linesjsi::Value CommRustModule::getOutboundKeysForUser(
auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt); auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
auto userIDRust = jsiStringToRustString(userID, rt); auto userIDRust = jsiStringToRustString(userID, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityGetOutboundKeysForUser( identityGetOutboundKeysForUser(
authUserIDRust, authUserIDRust,
authDeviceIDRust, authDeviceIDRust,
authAccessTokenRust, authAccessTokenRust,
userIDRust, userIDRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
Show All 16 Linesjsi::Value CommRustModule::getInboundKeysForUser(
auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt); auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
auto userIDRust = jsiStringToRustString(userID, rt); auto userIDRust = jsiStringToRustString(userID, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityGetInboundKeysForUser( identityGetInboundKeysForUser(
authUserIDRust, authUserIDRust,
authDeviceIDRust, authDeviceIDRust,
authAccessTokenRust, authAccessTokenRust,
userIDRust, userIDRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
}; };
if (!error.empty()) { if (!error.empty()) {
this->jsInvoker_->invokeAsync( this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); }); [error, promise]() { promise->reject(error); });
} }
}); });
} }
jsi::Value CommRustModule::versionSupported(jsi::Runtime &rt) { jsi::Value CommRustModule::versionSupported(jsi::Runtime &rt) {
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityVersionSupported(currentID); identityVersionSupported(currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
}; };
if (!error.empty()) { if (!error.empty()) {
this->jsInvoker_->invokeAsync( this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); }); [error, promise]() { promise->reject(error); });
} }
Show All 15 Linesjsi::Value CommRustModule::uploadOneTimeKeys(
auto notifOneTimePreKeysRust = auto notifOneTimePreKeysRust =
jsiStringArrayToRustVec(notifOneTimePreKeys, rt); jsiStringArrayToRustVec(notifOneTimePreKeys, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityUploadOneTimeKeys( identityUploadOneTimeKeys(
authUserIDRust, authUserIDRust,
authDeviceIDRust, authDeviceIDRust,
authAccessTokenRust, authAccessTokenRust,
contentOneTimePreKeysRust, contentOneTimePreKeysRust,
notifOneTimePreKeysRust, notifOneTimePreKeysRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
Show All 17 Linesjsi::Value CommRustModule::getKeyserverKeys(
auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt); auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
auto keyserverIDRust = jsiStringToRustString(keyserverID, rt); auto keyserverIDRust = jsiStringToRustString(keyserverID, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityGetKeyserverKeys( identityGetKeyserverKeys(
authUserIDRust, authUserIDRust,
authDeviceIDRust, authDeviceIDRust,
authAccessTokenRust, authAccessTokenRust,
keyserverIDRust, keyserverIDRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
Show All 9 Lines
View Options

services/terraform/modules/shared/variables.tf

Show All 13 Lines
} }
jsi::Value CommRustModule::generateNonce(jsi::Runtime &rt) { jsi::Value CommRustModule::generateNonce(jsi::Runtime &rt) {
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityGenerateNonce(currentID); identityGenerateNonce(currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
}; };
if (!error.empty()) { if (!error.empty()) {
this->jsInvoker_->invokeAsync( this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); }); [error, promise]() { promise->reject(error); });
} }
Show All 25 Linesjsi::Value CommRustModule::registerUser(
auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt); auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt);
auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt); auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityRegisterUser( identityRegisterUser(
usernameRust, usernameRust,
passwordRust, passwordRust,
keyPayloadRust, keyPayloadRust,
keyPayloadSignatureRust, keyPayloadSignatureRust,
contentPrekeyRust, contentPrekeyRust,
contentPrekeySignatureRust, contentPrekeySignatureRust,
notifPrekeyRust, notifPrekeyRust,
Show All 36 Linesjsi::Value CommRustModule::loginPasswordUser(
auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt); auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt);
auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt); auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityLoginPasswordUser( identityLoginPasswordUser(
usernameRust, usernameRust,
passwordRust, passwordRust,
keyPayloadRust, keyPayloadRust,
keyPayloadSignatureRust, keyPayloadSignatureRust,
contentPrekeyRust, contentPrekeyRust,
contentPrekeySignatureRust, contentPrekeySignatureRust,
notifPrekeyRust, notifPrekeyRust,
Show All 38 Linesjsi::Value CommRustModule::loginWalletUser(
auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt); auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
auto socialProofRust = jsiStringToRustString(socialProof, rt); auto socialProofRust = jsiStringToRustString(socialProof, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityLoginWalletUser( identityLoginWalletUser(
siweMessageRust, siweMessageRust,
siweSignatureRust, siweSignatureRust,
keyPayloadRust, keyPayloadRust,
keyPayloadSignatureRust, keyPayloadSignatureRust,
contentPrekeyRust, contentPrekeyRust,
contentPrekeySignatureRust, contentPrekeySignatureRust,
notifPrekeyRust, notifPrekeyRust,
Show All 23 Linesjsi::Value CommRustModule::updatePassword(
auto accessTokenRust = jsiStringToRustString(accessToken, rt); auto accessTokenRust = jsiStringToRustString(accessToken, rt);
auto passwordRust = jsiStringToRustString(password, rt); auto passwordRust = jsiStringToRustString(password, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityUpdateUserPassword( identityUpdateUserPassword(
userIDRust, userIDRust,
deviceIDRust, deviceIDRust,
accessTokenRust, accessTokenRust,
passwordRust, passwordRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
Show All 14 Linesjsi::Value CommRustModule::deleteUser(
auto deviceIDRust = jsiStringToRustString(deviceID, rt); auto deviceIDRust = jsiStringToRustString(deviceID, rt);
auto accessTokenRust = jsiStringToRustString(accessToken, rt); auto accessTokenRust = jsiStringToRustString(accessToken, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityDeleteUser( identityDeleteUser(
userIDRust, deviceIDRust, accessTokenRust, currentID); userIDRust, deviceIDRust, accessTokenRust, currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
}; };
if (!error.empty()) { if (!error.empty()) {
this->jsInvoker_->invokeAsync( this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); }); [error, promise]() { promise->reject(error); });
Show All 12 Linesjsi::Value CommRustModule::getOutboundKeysForUser(
auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt); auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
auto userIDRust = jsiStringToRustString(userID, rt); auto userIDRust = jsiStringToRustString(userID, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityGetOutboundKeysForUser( identityGetOutboundKeysForUser(
authUserIDRust, authUserIDRust,
authDeviceIDRust, authDeviceIDRust,
authAccessTokenRust, authAccessTokenRust,
userIDRust, userIDRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
Show All 16 Linesjsi::Value CommRustModule::getInboundKeysForUser(
auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt); auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
auto userIDRust = jsiStringToRustString(userID, rt); auto userIDRust = jsiStringToRustString(userID, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityGetInboundKeysForUser( identityGetInboundKeysForUser(
authUserIDRust, authUserIDRust,
authDeviceIDRust, authDeviceIDRust,
authAccessTokenRust, authAccessTokenRust,
userIDRust, userIDRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
}; };
if (!error.empty()) { if (!error.empty()) {
this->jsInvoker_->invokeAsync( this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); }); [error, promise]() { promise->reject(error); });
} }
}); });
} }
jsi::Value CommRustModule::versionSupported(jsi::Runtime &rt) { jsi::Value CommRustModule::versionSupported(jsi::Runtime &rt) {
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityVersionSupported(currentID); identityVersionSupported(currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
}; };
if (!error.empty()) { if (!error.empty()) {
this->jsInvoker_->invokeAsync( this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); }); [error, promise]() { promise->reject(error); });
} }
Show All 15 Linesjsi::Value CommRustModule::uploadOneTimeKeys(
auto notifOneTimePreKeysRust = auto notifOneTimePreKeysRust =
jsiStringArrayToRustVec(notifOneTimePreKeys, rt); jsiStringArrayToRustVec(notifOneTimePreKeys, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityUploadOneTimeKeys( identityUploadOneTimeKeys(
authUserIDRust, authUserIDRust,
authDeviceIDRust, authDeviceIDRust,
authAccessTokenRust, authAccessTokenRust,
contentOneTimePreKeysRust, contentOneTimePreKeysRust,
notifOneTimePreKeysRust, notifOneTimePreKeysRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
Show All 17 Linesjsi::Value CommRustModule::getKeyserverKeys(
auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt); auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
auto keyserverIDRust = jsiStringToRustString(keyserverID, rt); auto keyserverIDRust = jsiStringToRustString(keyserverID, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityGetKeyserverKeys( identityGetKeyserverKeys(
authUserIDRust, authUserIDRust,
authDeviceIDRust, authDeviceIDRust,
authAccessTokenRust, authAccessTokenRust,
keyserverIDRust, keyserverIDRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
Show All 9 Lines
View Options

services/terraform/remote/main.tf

Show All 13 Lines
} }
jsi::Value CommRustModule::generateNonce(jsi::Runtime &rt) { jsi::Value CommRustModule::generateNonce(jsi::Runtime &rt) {
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityGenerateNonce(currentID); identityGenerateNonce(currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
}; };
if (!error.empty()) { if (!error.empty()) {
this->jsInvoker_->invokeAsync( this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); }); [error, promise]() { promise->reject(error); });
} }
Show All 25 Linesjsi::Value CommRustModule::registerUser(
auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt); auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt);
auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt); auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityRegisterUser( identityRegisterUser(
usernameRust, usernameRust,
passwordRust, passwordRust,
keyPayloadRust, keyPayloadRust,
keyPayloadSignatureRust, keyPayloadSignatureRust,
contentPrekeyRust, contentPrekeyRust,
contentPrekeySignatureRust, contentPrekeySignatureRust,
notifPrekeyRust, notifPrekeyRust,
Show All 36 Linesjsi::Value CommRustModule::loginPasswordUser(
auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt); auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt);
auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt); auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityLoginPasswordUser( identityLoginPasswordUser(
usernameRust, usernameRust,
passwordRust, passwordRust,
keyPayloadRust, keyPayloadRust,
keyPayloadSignatureRust, keyPayloadSignatureRust,
contentPrekeyRust, contentPrekeyRust,
contentPrekeySignatureRust, contentPrekeySignatureRust,
notifPrekeyRust, notifPrekeyRust,
Show All 38 Linesjsi::Value CommRustModule::loginWalletUser(
auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt); auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
auto socialProofRust = jsiStringToRustString(socialProof, rt); auto socialProofRust = jsiStringToRustString(socialProof, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityLoginWalletUser( identityLoginWalletUser(
siweMessageRust, siweMessageRust,
siweSignatureRust, siweSignatureRust,
keyPayloadRust, keyPayloadRust,
keyPayloadSignatureRust, keyPayloadSignatureRust,
contentPrekeyRust, contentPrekeyRust,
contentPrekeySignatureRust, contentPrekeySignatureRust,
notifPrekeyRust, notifPrekeyRust,
Show All 23 Linesjsi::Value CommRustModule::updatePassword(
auto accessTokenRust = jsiStringToRustString(accessToken, rt); auto accessTokenRust = jsiStringToRustString(accessToken, rt);
auto passwordRust = jsiStringToRustString(password, rt); auto passwordRust = jsiStringToRustString(password, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityUpdateUserPassword( identityUpdateUserPassword(
userIDRust, userIDRust,
deviceIDRust, deviceIDRust,
accessTokenRust, accessTokenRust,
passwordRust, passwordRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
Show All 14 Linesjsi::Value CommRustModule::deleteUser(
auto deviceIDRust = jsiStringToRustString(deviceID, rt); auto deviceIDRust = jsiStringToRustString(deviceID, rt);
auto accessTokenRust = jsiStringToRustString(accessToken, rt); auto accessTokenRust = jsiStringToRustString(accessToken, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityDeleteUser( identityDeleteUser(
userIDRust, deviceIDRust, accessTokenRust, currentID); userIDRust, deviceIDRust, accessTokenRust, currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
}; };
if (!error.empty()) { if (!error.empty()) {
this->jsInvoker_->invokeAsync( this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); }); [error, promise]() { promise->reject(error); });
Show All 12 Linesjsi::Value CommRustModule::getOutboundKeysForUser(
auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt); auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
auto userIDRust = jsiStringToRustString(userID, rt); auto userIDRust = jsiStringToRustString(userID, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityGetOutboundKeysForUser( identityGetOutboundKeysForUser(
authUserIDRust, authUserIDRust,
authDeviceIDRust, authDeviceIDRust,
authAccessTokenRust, authAccessTokenRust,
userIDRust, userIDRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
Show All 16 Linesjsi::Value CommRustModule::getInboundKeysForUser(
auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt); auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
auto userIDRust = jsiStringToRustString(userID, rt); auto userIDRust = jsiStringToRustString(userID, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityGetInboundKeysForUser( identityGetInboundKeysForUser(
authUserIDRust, authUserIDRust,
authDeviceIDRust, authDeviceIDRust,
authAccessTokenRust, authAccessTokenRust,
userIDRust, userIDRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
}; };
if (!error.empty()) { if (!error.empty()) {
this->jsInvoker_->invokeAsync( this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); }); [error, promise]() { promise->reject(error); });
} }
}); });
} }
jsi::Value CommRustModule::versionSupported(jsi::Runtime &rt) { jsi::Value CommRustModule::versionSupported(jsi::Runtime &rt) {
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityVersionSupported(currentID); identityVersionSupported(currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
}; };
if (!error.empty()) { if (!error.empty()) {
this->jsInvoker_->invokeAsync( this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); }); [error, promise]() { promise->reject(error); });
} }
Show All 15 Linesjsi::Value CommRustModule::uploadOneTimeKeys(
auto notifOneTimePreKeysRust = auto notifOneTimePreKeysRust =
jsiStringArrayToRustVec(notifOneTimePreKeys, rt); jsiStringArrayToRustVec(notifOneTimePreKeys, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityUploadOneTimeKeys( identityUploadOneTimeKeys(
authUserIDRust, authUserIDRust,
authDeviceIDRust, authDeviceIDRust,
authAccessTokenRust, authAccessTokenRust,
contentOneTimePreKeysRust, contentOneTimePreKeysRust,
notifOneTimePreKeysRust, notifOneTimePreKeysRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
Show All 17 Linesjsi::Value CommRustModule::getKeyserverKeys(
auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt); auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
auto keyserverIDRust = jsiStringToRustString(keyserverID, rt); auto keyserverIDRust = jsiStringToRustString(keyserverID, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityGetKeyserverKeys( identityGetKeyserverKeys(
authUserIDRust, authUserIDRust,
authDeviceIDRust, authDeviceIDRust,
authAccessTokenRust, authAccessTokenRust,
keyserverIDRust, keyserverIDRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
Show All 9 Lines