Page MenuHomePhabricator
Differential D5031

[services] Rust Integration - Backup - Make check_error shared
ClosedPublic
Actions

Authored by • karol on Sep 1 2022, 11:54 PM.
Tags
None
Referenced Files
F5063927: D5031.diff
Thu, Mar 27, 3:24 AM
Unknown Object (File)
Sun, Mar 23, 3:48 PM
Unknown Object (File)
Sun, Mar 23, 6:36 AM
Unknown Object (File)
Fri, Mar 21, 10:31 PM
Unknown Object (File)
Tue, Mar 18, 7:08 AM
Unknown Object (File)
Thu, Mar 13, 12:14 AM
Unknown Object (File)
Thu, Mar 6, 5:03 AM
Unknown Object (File)
Wed, Mar 5, 4:40 PM
View All Files
Subscribers
• abosh
ashoat
atul
tomek

Details

Reviewers
• jon
• max
varun
tomek
Commits
rCOMM48b066b17f71: [services] Rust Integration - Backup - Make check_error shared
Summary

Depends on D5030

I just moved the function check_error to the mutual space tools following the DRY rule.

Test Plan
cd services
yarn run-integration-tests backup

Works as before

Diff Detail

Repository
rCOMM Comm
Branch
integrate-rust-diffs
Lint
No Lint Coverage
Unit
No Test Coverage

Event Timeline

• karol created this revision.Sep 1 2022, 11:54 PM
Herald added a reviewer: • jon. · View Herald TranscriptSep 1 2022, 11:54 PM
Herald added subscribers: • abosh, atul, tomek, ashoat. · View Herald Transcript
• karol updated this revision to Diff 16227.Sep 2 2022, 12:03 AM

rebase

• karol edited the summary of this revision. (Show Details)Sep 2 2022, 12:05 AM
• karol edited the test plan for this revision. (Show Details)
• karol added reviewers: • max, varun, tomek.
• karol edited the summary of this revision. (Show Details)
• karol added a parent revision: D5030: [services] Rust Integration - Backup - Make report_error shared.
Harbormaster completed remote builds in B11819: Diff 16224.Sep 2 2022, 12:07 AM
Harbormaster completed remote builds in B11822: Diff 16227.Sep 2 2022, 12:11 AM
• karol requested review of this revision.Sep 2 2022, 12:11 AM
• karol added a child revision: D5034: [services] Rust Integration - Backup - Rust - Add converting functions.Sep 2 2022, 3:55 AM
• karol planned changes to this revision.Sep 2 2022, 7:20 AM
• karol updated this revision to Diff 16250.Sep 2 2022, 7:21 AM
• karol edited the summary of this revision. (Show Details)

rebase

Harbormaster failed remote builds in B11845: Diff 16250!Sep 2 2022, 7:24 AM
tomek accepted this revision.Sep 5 2022, 7:42 AM
tomek added inline comments.
services/backup/blob_client/src/get_client.rs
118 ↗(On Diff #16250)

Is there a way to avoid ERROR_MESSAGES in every call? E.g. we can create a function that calls check_error(&ERROR_MESSAGES) or modify ERROR_MESSAGES to be a struct that has check method. We're considering changing the approach of handling errors, so maybe this comment shouldn't be addressed here, but might become useful when designing the new approach.

This revision is now accepted and ready to land.Sep 5 2022, 7:42 AM
• karol mentioned this in D5013: [services] Backup - Blob Get Client - Add base structure.Sep 6 2022, 1:43 AM
• karol updated this revision to Diff 16370.Sep 6 2022, 7:17 AM

update

Harbormaster completed remote builds in B11924: Diff 16370.Sep 6 2022, 7:27 AM
• karol updated this revision to Diff 16459.Sep 8 2022, 4:03 AM

rebase

This revision was landed with ongoing or failed builds.Sep 8 2022, 4:10 AM
Closed by commit rCOMM48b066b17f71: [services] Rust Integration - Backup - Make check_error shared (authored by • karol). · Explain Why
This revision was automatically updated to reflect the committed changes.
• karol added a commit: rCOMM48b066b17f71: [services] Rust Integration - Backup - Make check_error shared.
Harbormaster completed remote builds in B12004: Diff 16459.Sep 8 2022, 4:34 AM

Revision Contents
Changeset List

PathSize
services/
backup/
blob_client/
src/
20 lines
22 lines
10 lines

Diff 16227

View Options

services/backup/blob_client/src/get_client.rs

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::put_request; use proto::put_request;
use proto::put_request::Data::*; use proto::put_request::Data::*;
use proto::PutRequest; use proto::PutRequest;
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, c_char_pointer_to_string_new, check_error, c_char_pointer_to_string, c_char_pointer_to_string_new, report_error, string_to_c_char_pointer_new,
report_error, string_to_c_char_pointer, string_to_c_char_pointer_new,
}; };
use anyhow::bail; use anyhow::bail;
use crate::RUNTIME; use crate::RUNTIME;
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::ffi::CStr; use std::ffi::CStr;
▲ Show 20 Lines • Show All 168 Lines • ▼ Show 20 Lines if let Ok(mut grpc_client) =
} }
return Err(format!("could not access client for holder {}", holder)); return Err(format!("could not access client for holder {}", holder));
} }
Err("could not successfully connect to the blob server".to_string()) Err("could not successfully connect to the blob server".to_string())
} }
pub fn put_client_blocking_read_cxx( pub fn put_client_blocking_read_cxx(
holder_char: *const c_char, holder_char: *const c_char,
) -> Result<String, String> { ) -> anyhow::Result<String, 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)?; Ok(RUNTIME.block_on(async {
let response: Option<String> = RUNTIME.block_on(async {
if let Ok(mut clients) = CLIENTS.lock() { if let Ok(mut clients) = CLIENTS.lock() {
let maybe_client = clients.get_mut(&holder); let maybe_client = clients.get_mut(&holder);
if let Some(client) = maybe_client { if let Some(client) = maybe_client {
if let Some(data) = client.rx.recv().await { if let Some(data) = client.rx.recv().await {
return Some(data); return Ok(data);
} else { } else {
report_error( bail!("couldn't receive data via client's receiver");
&ERROR_MESSAGES,
"couldn't receive data via client's receiver",
Some("put"),
);
} }
} else { } else {
report_error( bail!(format!("no client detected for {} in blocking read", holder));
&ERROR_MESSAGES,
"no client detected in blocking read",
Some("put"),
);
} }
} else { } else {
report_error(&ERROR_MESSAGES, "couldn't access client", Some("put")); bail!("couldn't access clients");
} }
None })?)
});
check_error(&ERROR_MESSAGES)?;
response.ok_or("response not received properly".to_string())
} }
/** /**
* field index: * field index:
* 1 - holder (utf8 string) * 1 - holder (utf8 string)
* 2 - blob hash (utf8 string) * 2 - blob hash (utf8 string)
* 3 - data chunk (bytes) * 3 - data chunk (bytes)
*/ */
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines
View Options

services/backup/blob_client/src/put_client.rs

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::put_request; use proto::put_request;
use proto::put_request::Data::*; use proto::put_request::Data::*;
use proto::PutRequest; use proto::PutRequest;
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, c_char_pointer_to_string_new, check_error, c_char_pointer_to_string, c_char_pointer_to_string_new, report_error, string_to_c_char_pointer_new,
report_error, string_to_c_char_pointer, string_to_c_char_pointer_new,
}; };
use anyhow::bail; use anyhow::bail;
use crate::RUNTIME; use crate::RUNTIME;
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::ffi::CStr; use std::ffi::CStr;
▲ Show 20 Lines • Show All 168 Lines • ▼ Show 20 Lines if let Ok(mut grpc_client) =
} }
return Err(format!("could not access client for holder {}", holder)); return Err(format!("could not access client for holder {}", holder));
} }
Err("could not successfully connect to the blob server".to_string()) Err("could not successfully connect to the blob server".to_string())
} }
pub fn put_client_blocking_read_cxx( pub fn put_client_blocking_read_cxx(
holder_char: *const c_char, holder_char: *const c_char,
) -> Result<String, String> { ) -> anyhow::Result<String, 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)?; Ok(RUNTIME.block_on(async {
let response: Option<String> = RUNTIME.block_on(async {
if let Ok(mut clients) = CLIENTS.lock() { if let Ok(mut clients) = CLIENTS.lock() {
let maybe_client = clients.get_mut(&holder); let maybe_client = clients.get_mut(&holder);
if let Some(client) = maybe_client { if let Some(client) = maybe_client {
if let Some(data) = client.rx.recv().await { if let Some(data) = client.rx.recv().await {
return Some(data); return Ok(data);
} else { } else {
report_error( bail!("couldn't receive data via client's receiver");
&ERROR_MESSAGES,
"couldn't receive data via client's receiver",
Some("put"),
);
} }
} else { } else {
report_error( bail!(format!("no client detected for {} in blocking read", holder));
&ERROR_MESSAGES,
"no client detected in blocking read",
Some("put"),
);
} }
} else { } else {
report_error(&ERROR_MESSAGES, "couldn't access client", Some("put")); bail!("couldn't access clients");
} }
None })?)
});
check_error(&ERROR_MESSAGES)?;
response.ok_or("response not received properly".to_string())
} }
/** /**
* field index: * field index:
* 1 - holder (utf8 string) * 1 - holder (utf8 string)
* 2 - blob hash (utf8 string) * 2 - blob hash (utf8 string)
* 3 - data chunk (bytes) * 3 - data chunk (bytes)
*/ */
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines
View Options

services/backup/blob_client/src/tools.rs

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::put_request; use proto::put_request;
use proto::put_request::Data::*; use proto::put_request::Data::*;
use proto::PutRequest; use proto::PutRequest;
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, c_char_pointer_to_string_new, check_error, c_char_pointer_to_string, c_char_pointer_to_string_new, report_error, string_to_c_char_pointer_new,
report_error, string_to_c_char_pointer, string_to_c_char_pointer_new,
}; };
use anyhow::bail; use anyhow::bail;
use crate::RUNTIME; use crate::RUNTIME;
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::ffi::CStr; use std::ffi::CStr;
▲ Show 20 Lines • Show All 168 Lines • ▼ Show 20 Lines if let Ok(mut grpc_client) =
} }
return Err(format!("could not access client for holder {}", holder)); return Err(format!("could not access client for holder {}", holder));
} }
Err("could not successfully connect to the blob server".to_string()) Err("could not successfully connect to the blob server".to_string())
} }
pub fn put_client_blocking_read_cxx( pub fn put_client_blocking_read_cxx(
holder_char: *const c_char, holder_char: *const c_char,
) -> Result<String, String> { ) -> anyhow::Result<String, 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)?; Ok(RUNTIME.block_on(async {
let response: Option<String> = RUNTIME.block_on(async {
if let Ok(mut clients) = CLIENTS.lock() { if let Ok(mut clients) = CLIENTS.lock() {
let maybe_client = clients.get_mut(&holder); let maybe_client = clients.get_mut(&holder);
if let Some(client) = maybe_client { if let Some(client) = maybe_client {
if let Some(data) = client.rx.recv().await { if let Some(data) = client.rx.recv().await {
return Some(data); return Ok(data);
} else { } else {
report_error( bail!("couldn't receive data via client's receiver");
&ERROR_MESSAGES,
"couldn't receive data via client's receiver",
Some("put"),
);
} }
} else { } else {
report_error( bail!(format!("no client detected for {} in blocking read", holder));
&ERROR_MESSAGES,
"no client detected in blocking read",
Some("put"),
);
} }
} else { } else {
report_error(&ERROR_MESSAGES, "couldn't access client", Some("put")); bail!("couldn't access clients");
} }
None })?)
});
check_error(&ERROR_MESSAGES)?;
response.ok_or("response not received properly".to_string())
} }
/** /**
* field index: * field index:
* 1 - holder (utf8 string) * 1 - holder (utf8 string)
* 2 - blob hash (utf8 string) * 2 - blob hash (utf8 string)
* 3 - data chunk (bytes) * 3 - data chunk (bytes)
*/ */
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines