Page MenuHomePhabricator
Differential D11999

[CommRustModule] add JSI bindings for `findUserIdentities` RPC
ClosedPublic
Actions

Authored by will on May 10 2024, 9:49 PM.
Tags
None
Referenced Files
Unknown Object (File)
Sat, Mar 22, 5:27 AM
Unknown Object (File)
Feb 20 2025, 11:09 AM
Unknown Object (File)
Feb 19 2025, 8:14 PM
Unknown Object (File)
Feb 15 2025, 2:56 AM
Unknown Object (File)
Jan 20 2025, 9:56 AM
Unknown Object (File)
Dec 29 2024, 11:29 PM
Unknown Object (File)
Dec 29 2024, 11:29 PM
Unknown Object (File)
Dec 29 2024, 11:29 PM
View All 60 Files
Subscribers
ashoat
tomek

Details

Reviewers
kamil
bartek
Commits
rCOMMfdf6492c7fa5: [CommRustModule] add JSI bindings for `findUserIdentities` RPC
Summary

This diff exposes FindUserIdentities to JavaScript

Depends on D11998

Test Plan

Tested later in stack by calling rpc on web/native

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Revision Contents
Changeset List

PathSize
native/
cpp/
CommonCpp/
NativeModules/
6 lines
33 lines
_generated/
schema/
6 lines

Diff 40272

View Options

native/cpp/CommonCpp/NativeModules/CommRustModule.h

pub mod error; pub mod error;
pub mod identity; pub mod identity;
pub mod tunnelbroker; pub mod tunnelbroker;
// Re-export some dependencies which may need to be used by downstream crates // Re-export some dependencies which may need to be used by downstream crates
pub use tonic; pub use tonic;
use error::Error; use error::Error;
use std::path::Path;
use std::time::Duration; use std::time::Duration;
use tonic::transport::{Certificate, Channel, ClientTlsConfig}; use tonic::transport::Channel;
use tracing::info; use tracing::info;
const CERT_PATHS: &[&str] = &[
// MacOS and newer Ubuntu
"/etc/ssl/cert.pem",
// Common CA cert paths
"/etc/ssl/certs/ca-bundle.crt",
"/etc/ssl/certs/ca-certificates.crt",
];
const CONNECT_TIMEOUT_DURATION: Duration = Duration::from_secs(5); const CONNECT_TIMEOUT_DURATION: Duration = Duration::from_secs(5);
pub(crate) fn get_ca_cert_contents() -> Option<String> {
CERT_PATHS
.iter()
.map(Path::new)
.filter(|p| p.exists())
.filter_map(|f| std::fs::read_to_string(f).ok())
.next()
}
pub(crate) async fn get_grpc_service_channel( pub(crate) async fn get_grpc_service_channel(
url: &str, url: &str,
) -> Result<Channel, Error> { ) -> Result<Channel, Error> {
let ca_cert = crate::get_ca_cert_contents().expect("Unable to get CA bundle");
info!("Connecting to gRPC service at {}", url); info!("Connecting to gRPC service at {}", url);
let mut channel = Channel::from_shared(url.to_string())? let channel = Channel::from_shared(url.to_string())?
.connect_timeout(CONNECT_TIMEOUT_DURATION); .connect_timeout(CONNECT_TIMEOUT_DURATION);
// tls_config will fail if the underlying URI is only http://
if url.starts_with("https:") {
channel = channel.tls_config(
ClientTlsConfig::new().ca_certificate(Certificate::from_pem(&ca_cert)),
)?
}
Ok(channel.connect().await?) Ok(channel.connect().await?)
} }
View Options

native/cpp/CommonCpp/NativeModules/CommRustModule.cpp

pub mod error; pub mod error;
pub mod identity; pub mod identity;
pub mod tunnelbroker; pub mod tunnelbroker;
// Re-export some dependencies which may need to be used by downstream crates // Re-export some dependencies which may need to be used by downstream crates
pub use tonic; pub use tonic;
use error::Error; use error::Error;
use std::path::Path;
use std::time::Duration; use std::time::Duration;
use tonic::transport::{Certificate, Channel, ClientTlsConfig}; use tonic::transport::Channel;
use tracing::info; use tracing::info;
const CERT_PATHS: &[&str] = &[
// MacOS and newer Ubuntu
"/etc/ssl/cert.pem",
// Common CA cert paths
"/etc/ssl/certs/ca-bundle.crt",
"/etc/ssl/certs/ca-certificates.crt",
];
const CONNECT_TIMEOUT_DURATION: Duration = Duration::from_secs(5); const CONNECT_TIMEOUT_DURATION: Duration = Duration::from_secs(5);
pub(crate) fn get_ca_cert_contents() -> Option<String> {
CERT_PATHS
.iter()
.map(Path::new)
.filter(|p| p.exists())
.filter_map(|f| std::fs::read_to_string(f).ok())
.next()
}
pub(crate) async fn get_grpc_service_channel( pub(crate) async fn get_grpc_service_channel(
url: &str, url: &str,
) -> Result<Channel, Error> { ) -> Result<Channel, Error> {
let ca_cert = crate::get_ca_cert_contents().expect("Unable to get CA bundle");
info!("Connecting to gRPC service at {}", url); info!("Connecting to gRPC service at {}", url);
let mut channel = Channel::from_shared(url.to_string())? let channel = Channel::from_shared(url.to_string())?
.connect_timeout(CONNECT_TIMEOUT_DURATION); .connect_timeout(CONNECT_TIMEOUT_DURATION);
// tls_config will fail if the underlying URI is only http://
if url.starts_with("https:") {
channel = channel.tls_config(
ClientTlsConfig::new().ca_certificate(Certificate::from_pem(&ca_cert)),
)?
}
Ok(channel.connect().await?) Ok(channel.connect().await?)
} }
View Options

native/cpp/CommonCpp/_generated/rustJSI-generated.cpp

pub mod error; pub mod error;
pub mod identity; pub mod identity;
pub mod tunnelbroker; pub mod tunnelbroker;
// Re-export some dependencies which may need to be used by downstream crates // Re-export some dependencies which may need to be used by downstream crates
pub use tonic; pub use tonic;
use error::Error; use error::Error;
use std::path::Path;
use std::time::Duration; use std::time::Duration;
use tonic::transport::{Certificate, Channel, ClientTlsConfig}; use tonic::transport::Channel;
use tracing::info; use tracing::info;
const CERT_PATHS: &[&str] = &[
// MacOS and newer Ubuntu
"/etc/ssl/cert.pem",
// Common CA cert paths
"/etc/ssl/certs/ca-bundle.crt",
"/etc/ssl/certs/ca-certificates.crt",
];
const CONNECT_TIMEOUT_DURATION: Duration = Duration::from_secs(5); const CONNECT_TIMEOUT_DURATION: Duration = Duration::from_secs(5);
pub(crate) fn get_ca_cert_contents() -> Option<String> {
CERT_PATHS
.iter()
.map(Path::new)
.filter(|p| p.exists())
.filter_map(|f| std::fs::read_to_string(f).ok())
.next()
}
pub(crate) async fn get_grpc_service_channel( pub(crate) async fn get_grpc_service_channel(
url: &str, url: &str,
) -> Result<Channel, Error> { ) -> Result<Channel, Error> {
let ca_cert = crate::get_ca_cert_contents().expect("Unable to get CA bundle");
info!("Connecting to gRPC service at {}", url); info!("Connecting to gRPC service at {}", url);
let mut channel = Channel::from_shared(url.to_string())? let channel = Channel::from_shared(url.to_string())?
.connect_timeout(CONNECT_TIMEOUT_DURATION); .connect_timeout(CONNECT_TIMEOUT_DURATION);
// tls_config will fail if the underlying URI is only http://
if url.starts_with("https:") {
channel = channel.tls_config(
ClientTlsConfig::new().ca_certificate(Certificate::from_pem(&ca_cert)),
)?
}
Ok(channel.connect().await?) Ok(channel.connect().await?)
} }
View Options

native/cpp/CommonCpp/_generated/rustJSI.h

pub mod error; pub mod error;
pub mod identity; pub mod identity;
pub mod tunnelbroker; pub mod tunnelbroker;
// Re-export some dependencies which may need to be used by downstream crates // Re-export some dependencies which may need to be used by downstream crates
pub use tonic; pub use tonic;
use error::Error; use error::Error;
use std::path::Path;
use std::time::Duration; use std::time::Duration;
use tonic::transport::{Certificate, Channel, ClientTlsConfig}; use tonic::transport::Channel;
use tracing::info; use tracing::info;
const CERT_PATHS: &[&str] = &[
// MacOS and newer Ubuntu
"/etc/ssl/cert.pem",
// Common CA cert paths
"/etc/ssl/certs/ca-bundle.crt",
"/etc/ssl/certs/ca-certificates.crt",
];
const CONNECT_TIMEOUT_DURATION: Duration = Duration::from_secs(5); const CONNECT_TIMEOUT_DURATION: Duration = Duration::from_secs(5);
pub(crate) fn get_ca_cert_contents() -> Option<String> {
CERT_PATHS
.iter()
.map(Path::new)
.filter(|p| p.exists())
.filter_map(|f| std::fs::read_to_string(f).ok())
.next()
}
pub(crate) async fn get_grpc_service_channel( pub(crate) async fn get_grpc_service_channel(
url: &str, url: &str,
) -> Result<Channel, Error> { ) -> Result<Channel, Error> {
let ca_cert = crate::get_ca_cert_contents().expect("Unable to get CA bundle");
info!("Connecting to gRPC service at {}", url); info!("Connecting to gRPC service at {}", url);
let mut channel = Channel::from_shared(url.to_string())? let channel = Channel::from_shared(url.to_string())?
.connect_timeout(CONNECT_TIMEOUT_DURATION); .connect_timeout(CONNECT_TIMEOUT_DURATION);
// tls_config will fail if the underlying URI is only http://
if url.starts_with("https:") {
channel = channel.tls_config(
ClientTlsConfig::new().ca_certificate(Certificate::from_pem(&ca_cert)),
)?
}
Ok(channel.connect().await?) Ok(channel.connect().await?)
} }
View Options

native/schema/CommRustModuleSchema.js

Loading...