Page MenuHomePhabricator
Differential D10606

[lib] Narrow `LogIn[Response/Result]` to `MinimallyEncodedRawThreadInfos`
ClosedPublic
Actions

Authored by atul on Jan 11 2024, 8:54 AM.
Tags
None
Referenced Files
Unknown Object (File)
Tue, Apr 22, 7:11 PM
Unknown Object (File)
Mon, Apr 21, 5:37 AM
Unknown Object (File)
Sun, Apr 20, 9:46 AM
Unknown Object (File)
Thu, Apr 17, 1:09 PM
Unknown Object (File)
Thu, Apr 17, 1:05 PM
Unknown Object (File)
Thu, Apr 17, 7:29 AM
Unknown Object (File)
Thu, Apr 17, 4:14 AM
Unknown Object (File)
Thu, Apr 17, 1:44 AM
View All Files
Subscribers
None

Details

Reviewers
ashoat
ginsu
tomek
Commits
rCOMMc6999dbbc0a7: [lib] Narrow `LogIn[Response/Result]` to `MinimallyEncodedRawThreadInfos`
Summary

Followup to D10588. This is the first step in removing the invariant inside the

action.type === logInActionTypes.success ||
action.type === siweAuthActionTypes.success ||
action.type === registerActionTypes.success ||
action.type === fullStateSyncActionType

condition.

Depends on D10588

Test Plan

N/A, trusting flow

Diff Detail

Repository
rCOMM Comm
Branch
arcpatch-D10606 (branched from master)
Lint
No Lint Coverage
Unit
No Test Coverage

Event Timeline

atul created this revision.Jan 11 2024, 8:54 AM
atul added a child revision: D10608: [lib] Narrow `Register[Response/Result]` to `MinimallyEncodedRawThreadInfos`.Jan 11 2024, 9:03 AM
Harbormaster returned this revision to the author for changes because remote builds failed.Jan 11 2024, 9:10 AM
Harbormaster failed remote builds in B25700: Diff 35540!
atul mentioned this in D10609: [lib] Narrow `ClientFullStateSync` to `MinimallyEncodedRawThreadInfos`.Jan 11 2024, 9:19 AM
atul updated this revision to Diff 35550.Jan 11 2024, 9:37 AM

separate out ClientLogInResponse and ServerLogInResponse to address flow issue in keyserver (not sure why it didn't get caught pre-commit)

atul published this revision for review.Jan 11 2024, 9:44 AM
ashoat accepted this revision.Jan 11 2024, 9:49 AM
ashoat added inline comments.
lib/types/account-types.js
158–161 ↗(On Diff #35550)

We should make sure cookieChange is read-only

Note: the + shorthand will not work here because of the type spread operator

This revision is now accepted and ready to land.Jan 11 2024, 9:49 AM
Harbormaster completed remote builds in B25709: Diff 35550.Jan 11 2024, 10:03 AM
atul updated this revision to Diff 35588.Jan 14 2024, 3:09 PM

make cookieChange readonly

Harbormaster completed remote builds in B25739: Diff 35588.Jan 14 2024, 3:29 PM
Closed by commit rCOMMc6999dbbc0a7: [lib] Narrow `LogIn[Response/Result]` to `MinimallyEncodedRawThreadInfos` (authored by atul). · Explain WhyJan 14 2024, 4:11 PM
This revision was automatically updated to reflect the committed changes.
atul added a commit: rCOMMc6999dbbc0a7: [lib] Narrow `LogIn[Response/Result]` to `MinimallyEncodedRawThreadInfos`.
atul mentioned this in rCOMM5da040f1a485: [lib] Narrow `ClientFullStateSync` to `MinimallyEncodedRawThreadInfos`.Jan 22 2024, 11:49 AM

Revision Contents
Changeset List

PathSize
keyserver/
src/
responders/
18 lines
updaters/
4 lines
lib/
actions/
30 lines
types/
17 lines

Diff 35588

View Options

keyserver/src/responders/user-responders.js

mod proto { mod proto {
tonic::include_proto!("blob"); tonic::include_proto!("blob");
} }
use proto::blob_service_client::BlobServiceClient; use proto::blob_service_client::BlobServiceClient;
use proto::GetRequest; use proto::GetRequest;
use crate::constants::{BLOB_ADDRESS, MPSC_CHANNEL_BUFFER_CAPACITY}; use crate::constants::{BLOB_ADDRESS, MPSC_CHANNEL_BUFFER_CAPACITY};
use crate::tools::{ use crate::tools::{
c_char_pointer_to_string, check_error, report_error, string_to_c_char_pointer, c_char_pointer_to_string, c_char_pointer_to_string_new, check_error,
report_error, string_to_c_char_pointer, string_to_c_char_pointer_new,
}; };
use anyhow::bail;
use lazy_static::lazy_static; use lazy_static::lazy_static;
use libc; use libc;
use libc::c_char; use libc::c_char;
use std::collections::HashMap; use std::collections::HashMap;
use std::sync::{Arc, Mutex}; use std::sync::{Arc, Mutex};
use tokio::runtime::Runtime; use tokio::runtime::Runtime;
use tokio::sync::mpsc; use tokio::sync::mpsc;
use tokio::task::JoinHandle; use tokio::task::JoinHandle;
Show All 17 Linesfn is_initialized(holder: &String) -> bool {
if let Ok(clients) = CLIENTS.lock() { if let Ok(clients) = CLIENTS.lock() {
return clients.contains_key(holder); return clients.contains_key(holder);
} else { } else {
report_error(&ERROR_MESSAGES, "couldn't access client", Some("get")); report_error(&ERROR_MESSAGES, "couldn't access client", Some("get"));
} }
false false
} }
fn is_initialized_new(holder: &String) -> anyhow::Result<bool, anyhow::Error> {
if let Ok(clients) = CLIENTS.lock() {
return Ok(clients.contains_key(holder));
}
bail!("couldn't access client");
}
pub fn get_client_initialize_cxx( pub fn get_client_initialize_cxx(
holder_char: *const c_char, holder_char: *const c_char,
) -> Result<(), String> { ) -> Result<(), String> {
let holder = c_char_pointer_to_string(holder_char)?; let holder = c_char_pointer_to_string(holder_char)?;
if is_initialized(&holder) { if is_initialized(&holder) {
get_client_terminate_cxx(string_to_c_char_pointer(&holder)?)?; // get_client_terminate_cxx(string_to_c_char_pointer(&holder)?)?;
} }
assert!( assert!(
!is_initialized(&holder), !is_initialized(&holder),
"client cannot be initialized twice" "client cannot be initialized twice"
); );
// grpc // grpc
▲ Show 20 Lines • Show All 83 Lines • ▼ Show 20 Lines let response: Option<Vec<u8>> = RUNTIME.block_on(async {
None None
}); });
check_error(&ERROR_MESSAGES)?; check_error(&ERROR_MESSAGES)?;
response.ok_or("response could not be obtained".to_string()) response.ok_or("response could not be obtained".to_string())
} }
pub fn get_client_terminate_cxx( pub fn get_client_terminate_cxx(
holder_char: *const c_char, holder_char: *const c_char,
) -> Result<(), String> { ) -> anyhow::Result<(), anyhow::Error> {
let holder = c_char_pointer_to_string(holder_char)?; let holder = c_char_pointer_to_string_new(holder_char)?;
check_error(&ERROR_MESSAGES)?; if !is_initialized_new(&holder)? {
if !is_initialized(&holder) {
check_error(&ERROR_MESSAGES)?;
return Ok(()); return Ok(());
} }
if let Ok(mut clients) = CLIENTS.lock() { if let Ok(mut clients) = CLIENTS.lock() {
let maybe_client = clients.remove(&holder); match clients.remove(&holder) {
if let Some(client) = maybe_client { Some(client) => {
RUNTIME.block_on(async { RUNTIME.block_on(async {
if client.rx_handle.await.is_err() { if client.rx_handle.await.is_err() {
report_error( bail!(format!("awaiting for the client {} failed", holder));
&ERROR_MESSAGES, }
"wait for receiver handle failed", Ok(())
Some("get"), })?;
); }
None => {
bail!(format!("no client foudn for {}", holder));
} }
});
} else {
return Err("no client detected".to_string());
} }
} else { } else {
return Err("couldn't access client".to_string()); bail!("couldn't access client");
} }
assert!( if is_initialized_new(&holder)? {
!is_initialized(&holder), bail!("client transmitter handler released properly");
"client transmitter handler released properly" }
);
check_error(&ERROR_MESSAGES)?;
Ok(()) Ok(())
} }
View Options

keyserver/src/updaters/account-updaters.js

mod proto { mod proto {
tonic::include_proto!("blob"); tonic::include_proto!("blob");
} }
use proto::blob_service_client::BlobServiceClient; use proto::blob_service_client::BlobServiceClient;
use proto::GetRequest; use proto::GetRequest;
use crate::constants::{BLOB_ADDRESS, MPSC_CHANNEL_BUFFER_CAPACITY}; use crate::constants::{BLOB_ADDRESS, MPSC_CHANNEL_BUFFER_CAPACITY};
use crate::tools::{ use crate::tools::{
c_char_pointer_to_string, check_error, report_error, string_to_c_char_pointer, c_char_pointer_to_string, c_char_pointer_to_string_new, check_error,
report_error, string_to_c_char_pointer, string_to_c_char_pointer_new,
}; };
use anyhow::bail;
use lazy_static::lazy_static; use lazy_static::lazy_static;
use libc; use libc;
use libc::c_char; use libc::c_char;
use std::collections::HashMap; use std::collections::HashMap;
use std::sync::{Arc, Mutex}; use std::sync::{Arc, Mutex};
use tokio::runtime::Runtime; use tokio::runtime::Runtime;
use tokio::sync::mpsc; use tokio::sync::mpsc;
use tokio::task::JoinHandle; use tokio::task::JoinHandle;
Show All 17 Linesfn is_initialized(holder: &String) -> bool {
if let Ok(clients) = CLIENTS.lock() { if let Ok(clients) = CLIENTS.lock() {
return clients.contains_key(holder); return clients.contains_key(holder);
} else { } else {
report_error(&ERROR_MESSAGES, "couldn't access client", Some("get")); report_error(&ERROR_MESSAGES, "couldn't access client", Some("get"));
} }
false false
} }
fn is_initialized_new(holder: &String) -> anyhow::Result<bool, anyhow::Error> {
if let Ok(clients) = CLIENTS.lock() {
return Ok(clients.contains_key(holder));
}
bail!("couldn't access client");
}
pub fn get_client_initialize_cxx( pub fn get_client_initialize_cxx(
holder_char: *const c_char, holder_char: *const c_char,
) -> Result<(), String> { ) -> Result<(), String> {
let holder = c_char_pointer_to_string(holder_char)?; let holder = c_char_pointer_to_string(holder_char)?;
if is_initialized(&holder) { if is_initialized(&holder) {
get_client_terminate_cxx(string_to_c_char_pointer(&holder)?)?; // get_client_terminate_cxx(string_to_c_char_pointer(&holder)?)?;
} }
assert!( assert!(
!is_initialized(&holder), !is_initialized(&holder),
"client cannot be initialized twice" "client cannot be initialized twice"
); );
// grpc // grpc
▲ Show 20 Lines • Show All 83 Lines • ▼ Show 20 Lines let response: Option<Vec<u8>> = RUNTIME.block_on(async {
None None
}); });
check_error(&ERROR_MESSAGES)?; check_error(&ERROR_MESSAGES)?;
response.ok_or("response could not be obtained".to_string()) response.ok_or("response could not be obtained".to_string())
} }
pub fn get_client_terminate_cxx( pub fn get_client_terminate_cxx(
holder_char: *const c_char, holder_char: *const c_char,
) -> Result<(), String> { ) -> anyhow::Result<(), anyhow::Error> {
let holder = c_char_pointer_to_string(holder_char)?; let holder = c_char_pointer_to_string_new(holder_char)?;
check_error(&ERROR_MESSAGES)?; if !is_initialized_new(&holder)? {
if !is_initialized(&holder) {
check_error(&ERROR_MESSAGES)?;
return Ok(()); return Ok(());
} }
if let Ok(mut clients) = CLIENTS.lock() { if let Ok(mut clients) = CLIENTS.lock() {
let maybe_client = clients.remove(&holder); match clients.remove(&holder) {
if let Some(client) = maybe_client { Some(client) => {
RUNTIME.block_on(async { RUNTIME.block_on(async {
if client.rx_handle.await.is_err() { if client.rx_handle.await.is_err() {
report_error( bail!(format!("awaiting for the client {} failed", holder));
&ERROR_MESSAGES, }
"wait for receiver handle failed", Ok(())
Some("get"), })?;
); }
None => {
bail!(format!("no client foudn for {}", holder));
} }
});
} else {
return Err("no client detected".to_string());
} }
} else { } else {
return Err("couldn't access client".to_string()); bail!("couldn't access client");
} }
assert!( if is_initialized_new(&holder)? {
!is_initialized(&holder), bail!("client transmitter handler released properly");
"client transmitter handler released properly" }
);
check_error(&ERROR_MESSAGES)?;
Ok(()) Ok(())
} }
View Options

lib/actions/user-actions.js

mod proto { mod proto {
tonic::include_proto!("blob"); tonic::include_proto!("blob");
} }
use proto::blob_service_client::BlobServiceClient; use proto::blob_service_client::BlobServiceClient;
use proto::GetRequest; use proto::GetRequest;
use crate::constants::{BLOB_ADDRESS, MPSC_CHANNEL_BUFFER_CAPACITY}; use crate::constants::{BLOB_ADDRESS, MPSC_CHANNEL_BUFFER_CAPACITY};
use crate::tools::{ use crate::tools::{
c_char_pointer_to_string, check_error, report_error, string_to_c_char_pointer, c_char_pointer_to_string, c_char_pointer_to_string_new, check_error,
report_error, string_to_c_char_pointer, string_to_c_char_pointer_new,
}; };
use anyhow::bail;
use lazy_static::lazy_static; use lazy_static::lazy_static;
use libc; use libc;
use libc::c_char; use libc::c_char;
use std::collections::HashMap; use std::collections::HashMap;
use std::sync::{Arc, Mutex}; use std::sync::{Arc, Mutex};
use tokio::runtime::Runtime; use tokio::runtime::Runtime;
use tokio::sync::mpsc; use tokio::sync::mpsc;
use tokio::task::JoinHandle; use tokio::task::JoinHandle;
Show All 17 Linesfn is_initialized(holder: &String) -> bool {
if let Ok(clients) = CLIENTS.lock() { if let Ok(clients) = CLIENTS.lock() {
return clients.contains_key(holder); return clients.contains_key(holder);
} else { } else {
report_error(&ERROR_MESSAGES, "couldn't access client", Some("get")); report_error(&ERROR_MESSAGES, "couldn't access client", Some("get"));
} }
false false
} }
fn is_initialized_new(holder: &String) -> anyhow::Result<bool, anyhow::Error> {
if let Ok(clients) = CLIENTS.lock() {
return Ok(clients.contains_key(holder));
}
bail!("couldn't access client");
}
pub fn get_client_initialize_cxx( pub fn get_client_initialize_cxx(
holder_char: *const c_char, holder_char: *const c_char,
) -> Result<(), String> { ) -> Result<(), String> {
let holder = c_char_pointer_to_string(holder_char)?; let holder = c_char_pointer_to_string(holder_char)?;
if is_initialized(&holder) { if is_initialized(&holder) {
get_client_terminate_cxx(string_to_c_char_pointer(&holder)?)?; // get_client_terminate_cxx(string_to_c_char_pointer(&holder)?)?;
} }
assert!( assert!(
!is_initialized(&holder), !is_initialized(&holder),
"client cannot be initialized twice" "client cannot be initialized twice"
); );
// grpc // grpc
▲ Show 20 Lines • Show All 83 Lines • ▼ Show 20 Lines let response: Option<Vec<u8>> = RUNTIME.block_on(async {
None None
}); });
check_error(&ERROR_MESSAGES)?; check_error(&ERROR_MESSAGES)?;
response.ok_or("response could not be obtained".to_string()) response.ok_or("response could not be obtained".to_string())
} }
pub fn get_client_terminate_cxx( pub fn get_client_terminate_cxx(
holder_char: *const c_char, holder_char: *const c_char,
) -> Result<(), String> { ) -> anyhow::Result<(), anyhow::Error> {
let holder = c_char_pointer_to_string(holder_char)?; let holder = c_char_pointer_to_string_new(holder_char)?;
check_error(&ERROR_MESSAGES)?; if !is_initialized_new(&holder)? {
if !is_initialized(&holder) {
check_error(&ERROR_MESSAGES)?;
return Ok(()); return Ok(());
} }
if let Ok(mut clients) = CLIENTS.lock() { if let Ok(mut clients) = CLIENTS.lock() {
let maybe_client = clients.remove(&holder); match clients.remove(&holder) {
if let Some(client) = maybe_client { Some(client) => {
RUNTIME.block_on(async { RUNTIME.block_on(async {
if client.rx_handle.await.is_err() { if client.rx_handle.await.is_err() {
report_error( bail!(format!("awaiting for the client {} failed", holder));
&ERROR_MESSAGES, }
"wait for receiver handle failed", Ok(())
Some("get"), })?;
); }
None => {
bail!(format!("no client foudn for {}", holder));
} }
});
} else {
return Err("no client detected".to_string());
} }
} else { } else {
return Err("couldn't access client".to_string()); bail!("couldn't access client");
} }
assert!( if is_initialized_new(&holder)? {
!is_initialized(&holder), bail!("client transmitter handler released properly");
"client transmitter handler released properly" }
);
check_error(&ERROR_MESSAGES)?;
Ok(()) Ok(())
} }
View Options

lib/types/account-types.js

mod proto { mod proto {
tonic::include_proto!("blob"); tonic::include_proto!("blob");
} }
use proto::blob_service_client::BlobServiceClient; use proto::blob_service_client::BlobServiceClient;
use proto::GetRequest; use proto::GetRequest;
use crate::constants::{BLOB_ADDRESS, MPSC_CHANNEL_BUFFER_CAPACITY}; use crate::constants::{BLOB_ADDRESS, MPSC_CHANNEL_BUFFER_CAPACITY};
use crate::tools::{ use crate::tools::{
c_char_pointer_to_string, check_error, report_error, string_to_c_char_pointer, c_char_pointer_to_string, c_char_pointer_to_string_new, check_error,
report_error, string_to_c_char_pointer, string_to_c_char_pointer_new,
}; };
use anyhow::bail;
use lazy_static::lazy_static; use lazy_static::lazy_static;
use libc; use libc;
use libc::c_char; use libc::c_char;
use std::collections::HashMap; use std::collections::HashMap;
use std::sync::{Arc, Mutex}; use std::sync::{Arc, Mutex};
use tokio::runtime::Runtime; use tokio::runtime::Runtime;
use tokio::sync::mpsc; use tokio::sync::mpsc;
use tokio::task::JoinHandle; use tokio::task::JoinHandle;
Show All 17 Linesfn is_initialized(holder: &String) -> bool {
if let Ok(clients) = CLIENTS.lock() { if let Ok(clients) = CLIENTS.lock() {
return clients.contains_key(holder); return clients.contains_key(holder);
} else { } else {
report_error(&ERROR_MESSAGES, "couldn't access client", Some("get")); report_error(&ERROR_MESSAGES, "couldn't access client", Some("get"));
} }
false false
} }
fn is_initialized_new(holder: &String) -> anyhow::Result<bool, anyhow::Error> {
if let Ok(clients) = CLIENTS.lock() {
return Ok(clients.contains_key(holder));
}
bail!("couldn't access client");
}
pub fn get_client_initialize_cxx( pub fn get_client_initialize_cxx(
holder_char: *const c_char, holder_char: *const c_char,
) -> Result<(), String> { ) -> Result<(), String> {
let holder = c_char_pointer_to_string(holder_char)?; let holder = c_char_pointer_to_string(holder_char)?;
if is_initialized(&holder) { if is_initialized(&holder) {
get_client_terminate_cxx(string_to_c_char_pointer(&holder)?)?; // get_client_terminate_cxx(string_to_c_char_pointer(&holder)?)?;
} }
assert!( assert!(
!is_initialized(&holder), !is_initialized(&holder),
"client cannot be initialized twice" "client cannot be initialized twice"
); );
// grpc // grpc
▲ Show 20 Lines • Show All 83 Lines • ▼ Show 20 Lines let response: Option<Vec<u8>> = RUNTIME.block_on(async {
None None
}); });
check_error(&ERROR_MESSAGES)?; check_error(&ERROR_MESSAGES)?;
response.ok_or("response could not be obtained".to_string()) response.ok_or("response could not be obtained".to_string())
} }
pub fn get_client_terminate_cxx( pub fn get_client_terminate_cxx(
holder_char: *const c_char, holder_char: *const c_char,
) -> Result<(), String> { ) -> anyhow::Result<(), anyhow::Error> {
let holder = c_char_pointer_to_string(holder_char)?; let holder = c_char_pointer_to_string_new(holder_char)?;
check_error(&ERROR_MESSAGES)?; if !is_initialized_new(&holder)? {
if !is_initialized(&holder) {
check_error(&ERROR_MESSAGES)?;
return Ok(()); return Ok(());
} }
if let Ok(mut clients) = CLIENTS.lock() { if let Ok(mut clients) = CLIENTS.lock() {
let maybe_client = clients.remove(&holder); match clients.remove(&holder) {
if let Some(client) = maybe_client { Some(client) => {
RUNTIME.block_on(async { RUNTIME.block_on(async {
if client.rx_handle.await.is_err() { if client.rx_handle.await.is_err() {
report_error( bail!(format!("awaiting for the client {} failed", holder));
&ERROR_MESSAGES, }
"wait for receiver handle failed", Ok(())
Some("get"), })?;
); }
None => {
bail!(format!("no client foudn for {}", holder));
} }
});
} else {
return Err("no client detected".to_string());
} }
} else { } else {
return Err("couldn't access client".to_string()); bail!("couldn't access client");
} }
assert!( if is_initialized_new(&holder)? {
!is_initialized(&holder), bail!("client transmitter handler released properly");
"client transmitter handler released properly" }
);
check_error(&ERROR_MESSAGES)?;
Ok(()) Ok(())
} }