zksync_protobuf_config 0.1.0

Protobuf deserialization for ZKsync configs
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

use anyhow::Context as _;
use zksync_config::configs::object_store::{ObjectStoreConfig, ObjectStoreMode};
use zksync_protobuf::{repr::ProtoRepr, required};

use crate::proto::object_store as proto;

impl ProtoRepr for proto::ObjectStore {
    type Type = ObjectStoreConfig;

    fn read(&self) -> anyhow::Result<Self::Type> {
        let mode = required(&self.mode).context("mode")?;
        let mode = match mode {
            proto::object_store::Mode::Gcs(mode) => ObjectStoreMode::GCS {
                bucket_base_url: required(&mode.bucket_base_url)
                    .context("bucket_base_url")?
                    .clone(),
            },
            proto::object_store::Mode::GcsWithCredentialFile(mode) => {
                ObjectStoreMode::GCSWithCredentialFile {
                    bucket_base_url: required(&mode.bucket_base_url)
                        .context("bucket_base_url")?
                        .clone(),
                    gcs_credential_file_path: required(&mode.gcs_credential_file_path)
                        .context("gcs_credential_file_path")?
                        .clone(),
                }
            }
            proto::object_store::Mode::GcsAnonymousReadOnly(mode) => {
                ObjectStoreMode::GCSAnonymousReadOnly {
                    bucket_base_url: required(&mode.bucket_base_url)
                        .context("bucket_base_url")?
                        .clone(),
                }
            }
            proto::object_store::Mode::FileBacked(mode) => ObjectStoreMode::FileBacked {
                file_backed_base_path: required(&mode.file_backed_base_path)
                    .context("file_backed_base_path")?
                    .clone(),
            },
        };

        Ok(Self::Type {
            mode,
            max_retries: required(&self.max_retries)
                .and_then(|x| Ok((*x).try_into()?))
                .context("max_retries")?,
            local_mirror_path: self.local_mirror_path.clone(),
        })
    }

    fn build(this: &Self::Type) -> Self {
        let mode = match &this.mode {
            ObjectStoreMode::GCS { bucket_base_url } => {
                proto::object_store::Mode::Gcs(proto::object_store::Gcs {
                    bucket_base_url: Some(bucket_base_url.clone()),
                })
            }
            ObjectStoreMode::GCSWithCredentialFile {
                bucket_base_url,
                gcs_credential_file_path,
            } => proto::object_store::Mode::GcsWithCredentialFile(
                proto::object_store::GcsWithCredentialFile {
                    bucket_base_url: Some(bucket_base_url.clone()),
                    gcs_credential_file_path: Some(gcs_credential_file_path.clone()),
                },
            ),
            ObjectStoreMode::GCSAnonymousReadOnly { bucket_base_url } => {
                proto::object_store::Mode::GcsAnonymousReadOnly(
                    proto::object_store::GcsAnonymousReadOnly {
                        bucket_base_url: Some(bucket_base_url.clone()),
                    },
                )
            }
            ObjectStoreMode::FileBacked {
                file_backed_base_path,
            } => proto::object_store::Mode::FileBacked(proto::object_store::FileBacked {
                file_backed_base_path: Some(file_backed_base_path.clone()),
            }),
        };

        Self {
            mode: Some(mode),
            max_retries: Some(this.max_retries.into()),
            local_mirror_path: this.local_mirror_path.clone(),
        }
    }
}