Rename LocalPendingEnrollment to PKILocalPendingEnrollment.

Author: AureliaDolo

docs/rfcs/1020-pki-support.md

@@ -116,7 +116,7 @@ and verify that the chosen certificate is able to sign a payload by default by u
 
 ### Create the local part of the async enrollment
 
-[`pki_enrollment_create_local_pending`] create a pending enrollment ([`LocalPendingEnrollment`]) consisting of the following information:
+[`pki_enrollment_create_local_pending`] create a pending enrollment ([`PKILocalPendingEnrollment`]) consisting of the following information:
 
 - Certificate ref (provided)
 - Server addr (provided)
@@ -128,7 +128,7 @@ and verify that the chosen certificate is able to sign a payload by default by u
 
 The pending enrollment contains almost everything to create a device only missing the organization verification key that will be sent with the "accept" payload response ([`pki_enrollment_load_accept_payload`])
 
-[`LocalPendingEnrollment`]: https://github.com/Scille/parsec-cloud/blob/df7bc6891989830c4d93f0b88ddaac9ade6b620c/libparsec/crates/types/schema/pki/local_pending_enrollment.json5
+[`PKILocalPendingEnrollment`]: https://github.com/Scille/parsec-cloud/blob/df7bc6891989830c4d93f0b88ddaac9ade6b620c/libparsec/crates/types/schema/pki/local_pending_enrollment.json5
 
 ### Submit the request to join an organization
 

libparsec/crates/platform_device_loader/src/lib.rs

@@ -767,7 +767,7 @@ impl From<SaveDeviceError> for SavePkiLocalPendingError {
 }
 
 pub async fn save_pki_local_pending(
-    local_pending: LocalPendingEnrollment,
+    local_pending: PKILocalPendingEnrollment,
     local_file: PathBuf,
 ) -> Result<(), SavePkiLocalPendingError> {
     log::debug!("Saving local device at {}", local_file.display());
@@ -784,6 +784,6 @@ pub enum ListPkiLocalPendingError {
 
 pub async fn list_pki_local_pending(
     config_dir: &Path,
-) -> Result<Vec<LocalPendingEnrollment>, ListPkiLocalPendingError> {
+) -> Result<Vec<PKILocalPendingEnrollment>, ListPkiLocalPendingError> {
     platform::list_pki_local_pending(config_dir).await
 }

libparsec/crates/platform_device_loader/src/native/mod.rs

@@ -522,7 +522,7 @@ pub(super) fn is_keyring_available() -> bool {
 }
 
 pub async fn save_pki_local_pending(
-    local_pending: LocalPendingEnrollment,
+    local_pending: PKILocalPendingEnrollment,
     local_file: PathBuf,
 ) -> Result<(), SavePkiLocalPendingError> {
     let file_content = local_pending.dump();
@@ -533,7 +533,7 @@ pub async fn save_pki_local_pending(
 
 pub async fn list_pki_local_pending(
     config_dir: &Path,
-) -> Result<Vec<LocalPendingEnrollment>, ListPkiLocalPendingError> {
+) -> Result<Vec<PKILocalPendingEnrollment>, ListPkiLocalPendingError> {
     let pending_dir = crate::get_local_pending_dir(config_dir);
     let mut files = find_local_pending_files(&pending_dir).await?;
 
@@ -573,12 +573,12 @@ async fn find_local_pending_files(path: &Path) -> Result<Vec<PathBuf>, ListPkiLo
     Ok(files)
 }
 
-async fn load_pki_pending_file(path: &Path) -> Result<LocalPendingEnrollment, LoadFileError> {
+async fn load_pki_pending_file(path: &Path) -> Result<PKILocalPendingEnrollment, LoadFileError> {
     let content = tokio::fs::read(path)
         .await
         .map_err(Into::into)
         .map_err(LoadFileError::InvalidPath)?;
-    LocalPendingEnrollment::load(&content)
+    PKILocalPendingEnrollment::load(&content)
         .inspect_err(
             |err| log::debug!(path:% = path.display(), err:%; "Failed to load pki pending file"),
         )

libparsec/crates/platform_device_loader/src/web/internal.rs

@@ -268,7 +268,7 @@ impl Storage {
     pub(crate) async fn save_pki_local_pending(
         &self,
         local_file: PathBuf,
-        file_data: LocalPendingEnrollment,
+        file_data: PKILocalPendingEnrollment,
     ) -> Result<(), SaveRawDataError> {
         let data = file_data.dump();
         self.save_raw_data(&local_file, &data).await
@@ -277,7 +277,7 @@ impl Storage {
     pub(crate) async fn list_pki_local_pending(
         &self,
         config_dir: &Path,
-    ) -> Result<Vec<LocalPendingEnrollment>, ListPkiLocalPendingError> {
+    ) -> Result<Vec<PKILocalPendingEnrollment>, ListPkiLocalPendingError> {
         let pending_dir = crate::get_local_pending_dir(config_dir);
         let file_entries = self
             .list_file_entries(&pending_dir, crate::LOCAL_PENDING_EXT)
@@ -318,12 +318,12 @@ async fn load_available_device(file: &File) -> Result<AvailableDevice, LoadAvail
 
 async fn load_pki_local_pending(
     file: &File,
-) -> Result<LocalPendingEnrollment, LoadPkiLocalPendingError> {
+) -> Result<PKILocalPendingEnrollment, LoadPkiLocalPendingError> {
     let raw_data = file
         .read_to_end()
         .await
         .map_err(LoadPkiLocalPendingError::ReadToEnd)?;
-    LocalPendingEnrollment::load(&raw_data)
+    PKILocalPendingEnrollment::load(&raw_data)
         .inspect_err(|err| {
             log::warn!(
                 path:% = file.path().display(),

libparsec/crates/platform_device_loader/src/web/mod.rs

@@ -177,7 +177,7 @@ pub(super) async fn remove_device(device_path: &Path) -> Result<(), RemoveDevice
 }
 
 pub(super) async fn save_pki_local_pending(
-    local_pending: LocalPendingEnrollment,
+    local_pending: PKILocalPendingEnrollment,
     local_file: PathBuf,
 ) -> Result<(), SavePkiLocalPendingError> {
     let Ok(storage) = Storage::new().await.inspect_err(|e| {
@@ -193,7 +193,7 @@ pub(super) async fn save_pki_local_pending(
 
 pub(super) async fn list_pki_local_pending(
     config_dir: &Path,
-) -> Result<Vec<LocalPendingEnrollment>, ListPkiLocalPendingError> {
+) -> Result<Vec<PKILocalPendingEnrollment>, ListPkiLocalPendingError> {
     let Ok(storage) = Storage::new().await.inspect_err(|e| {
         log::error!("Failed to access storage: {e}");
     }) else {

libparsec/crates/platform_device_loader/tests/units/pki/save.rs

@@ -4,7 +4,7 @@ use libparsec_testbed::TestbedEnv;
 use libparsec_tests_fixtures::prelude::*;
 use libparsec_tests_lite::parsec_test;
 use libparsec_types::{
-    Bytes, LocalPendingEnrollment, PKIEnrollmentID, ParsecPkiEnrollmentAddr,
+    Bytes, PKIEnrollmentID, PKILocalPendingEnrollment, ParsecPkiEnrollmentAddr,
     PkiEnrollmentSubmitPayload, X509CertificateHash,
 };
 
@@ -19,7 +19,7 @@ async fn ok_simple(tmp_path: TmpPath, env: &TestbedEnv) {
         alice_device.organization_addr.clone(),
         alice_device.organization_id().clone(),
     );
-    let local_pending = LocalPendingEnrollment {
+    let local_pending = PKILocalPendingEnrollment {
         cert_ref: X509CertificateHash::fake_sha256().into(),
         addr: pki_addr,
         submitted_on: "2000-01-01T00:00:00Z".parse().unwrap(),

libparsec/crates/platform_pki/src/shared/mod.rs

@@ -12,7 +12,7 @@ use crate::{
     EncryptedMessage, PkiSignatureAlgorithm,
 };
 use libparsec_types::{
-    DateTime, LocalPendingEnrollment, PKIEnrollmentID, ParsecPkiEnrollmentAddr,
+    DateTime, PKIEnrollmentID, PKILocalPendingEnrollment, ParsecPkiEnrollmentAddr,
     PkiEnrollmentAnswerPayload, PkiEnrollmentSubmitPayload, PrivateParts, SecretKey,
     X509CertificateReference,
 };
@@ -88,7 +88,7 @@ pub fn create_local_pending(
     submitted_on: DateTime,
     payload: PkiEnrollmentSubmitPayload,
     private_parts: PrivateParts,
-) -> Result<LocalPendingEnrollment, crate::errors::CreateLocalPendingError> {
+) -> Result<PKILocalPendingEnrollment, crate::errors::CreateLocalPendingError> {
     let key = SecretKey::generate();
     let EncryptedMessage {
         cert_ref,
@@ -97,7 +97,7 @@ pub fn create_local_pending(
     } = encrypt_message(key.as_ref(), cert_ref)?;
     let ciphered_private_parts = key.encrypt(&private_parts.dump()).into();
 
-    let local_pending = LocalPendingEnrollment {
+    let local_pending = PKILocalPendingEnrollment {
         cert_ref,
         addr,
         submitted_on,

libparsec/crates/types/schema/pki/local_pending_enrollment.json5

@@ -1,5 +1,5 @@
 {
-    "label": "LocalPendingEnrollment",
+    "label": "PKILocalPendingEnrollment",
     "type": "local_pending_enrollment",
     "other_fields": [
         {

libparsec/crates/types/src/pki/mod.rs

@@ -140,10 +140,10 @@ impl_transparent_data_format_conversion!(
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 #[serde(
-    into = "LocalPendingEnrollmentData",
-    try_from = "LocalPendingEnrollmentData"
+    into = "PKILocalPendingEnrollmentData",
+    try_from = "PKILocalPendingEnrollmentData"
 )]
-pub struct LocalPendingEnrollment {
+pub struct PKILocalPendingEnrollment {
     pub cert_ref: X509CertificateReference,
     pub addr: ParsecPkiEnrollmentAddr,
     pub submitted_on: DateTime,
@@ -154,7 +154,7 @@ pub struct LocalPendingEnrollment {
     pub ciphertext: Bytes,
 }
 
-impl LocalPendingEnrollment {
+impl PKILocalPendingEnrollment {
     pub fn load(raw: &[u8]) -> DataResult<Self> {
         format_vx_load(raw)
     }
@@ -166,10 +166,10 @@ impl LocalPendingEnrollment {
 
 parsec_data!("schema/pki/local_pending_enrollment.json5");
 
-impl TryFrom<LocalPendingEnrollmentData> for LocalPendingEnrollment {
+impl TryFrom<PKILocalPendingEnrollmentData> for PKILocalPendingEnrollment {
     type Error = &'static str;
 
-    fn try_from(data: LocalPendingEnrollmentData) -> Result<Self, Self::Error> {
+    fn try_from(data: PKILocalPendingEnrollmentData) -> Result<Self, Self::Error> {
         let addr = {
             let server_addr =
                 ParsecAddr::from_http_url(&data.server_url).map_err(|_| "Invalid server URL")?;
@@ -188,8 +188,8 @@ impl TryFrom<LocalPendingEnrollmentData> for LocalPendingEnrollment {
     }
 }
 
-impl From<LocalPendingEnrollment> for LocalPendingEnrollmentData {
-    fn from(obj: LocalPendingEnrollment) -> Self {
+impl From<PKILocalPendingEnrollment> for PKILocalPendingEnrollmentData {
+    fn from(obj: PKILocalPendingEnrollment) -> Self {
         let server_url = {
             let server_addr = ParsecAddr::new(
                 obj.addr.hostname().to_string(),

libparsec/crates/types/tests/unit/pki.rs

@@ -209,7 +209,7 @@ fn serde_pki_enrollment_submit_payload() {
         "6f454350e17d34cb15e3f2cd88067b5d4ab38d4c08a001"
     )[..],
     Box::new(|alice: &Device| {
-        LocalPendingEnrollment {
+        PKILocalPendingEnrollment {
             cert_ref: X509CertificateReference::from(X509CertificateHash::fake_sha256())
                 .add_or_replace_uri(X509WindowsCngURI::from(&b"foo"[..])),
             addr: ParsecPkiEnrollmentAddr::from_str(
@@ -265,7 +265,7 @@ fn serde_pki_enrollment_submit_payload() {
         "75bbae9cd9062204d0"
     )[..],
     Box::new(|alice: &Device| {
-        LocalPendingEnrollment {
+        PKILocalPendingEnrollment {
             cert_ref: X509CertificateReference::from(X509CertificateHash::fake_sha256()),
             addr: ParsecPkiEnrollmentAddr::from_str(
                 "parsec3://parsec.example.com/my_org?a=pki_enrollment",
@@ -288,17 +288,17 @@ fn serde_pki_enrollment_submit_payload() {
 fn serde_local_pending_enrollment(
     alice: &Device,
     #[case] raw: &[u8],
-    #[case] generate_expected: Box<dyn FnOnce(&Device) -> LocalPendingEnrollment>,
+    #[case] generate_expected: Box<dyn FnOnce(&Device) -> PKILocalPendingEnrollment>,
 ) {
     let expected = generate_expected(alice);
 
     println!("***expected: {:?}", expected.dump());
-    let data = LocalPendingEnrollment::load(raw).unwrap();
+    let data = PKILocalPendingEnrollment::load(raw).unwrap();
     p_assert_eq!(data, expected);
 
     // Also test serialization round trip
     let raw = data.dump();
-    let data = LocalPendingEnrollment::load(&raw).unwrap();
+    let data = PKILocalPendingEnrollment::load(&raw).unwrap();
 
     p_assert_eq!(data, expected);
 }