ng_repo/
errors.rs

1// Copyright (c) 2022-2025 Niko Bonnieure, Par le Peuple, NextGraph.org developers
2// All rights reserved.
3// Licensed under the Apache License, Version 2.0
4// <LICENSE-APACHE2 or http://www.apache.org/licenses/LICENSE-2.0>
5// or the MIT license <LICENSE-MIT or http://opensource.org/licenses/MIT>,
6// at your option. All files in the project carrying such
7// notice may not be copied, modified, or distributed except
8// according to those terms.
9
10//! Errors
11
12use core::fmt;
13use std::error::Error;
14
15use num_enum::IntoPrimitive;
16use num_enum::TryFromPrimitive;
17
18pub use crate::commit::{CommitLoadError, CommitVerifyError};
19use crate::file::FileError;
20use crate::log::*;
21use crate::object::Object;
22use crate::types::BlockId;
23
24#[derive(Debug, Eq, PartialEq, Clone)]
25#[repr(u16)]
26pub enum NgError {
27    InvalidSignature,
28    IncompleteSignature,
29    SerializationError,
30    EncryptionError,
31    DecryptionError,
32    InvalidValue,
33    ConnectionNotFound,
34    InvalidKey,
35    InvalidInvitation,
36    InvalidCreateAccount,
37    InvalidFileFormat,
38    InvalidArgument,
39    PermissionDenied,
40    InvalidPazzle,
41    InvalidMnemonic,
42    CommitLoadError(CommitLoadError),
43    ObjectParseError(ObjectParseError),
44    StorageError(StorageError),
45    NotFound,
46    JsStorageKeyNotFound,
47    IoError,
48    CommitVerifyError(CommitVerifyError),
49    LocalBrokerNotInitialized,
50    JsStorageReadError,
51    JsStorageWriteError(String),
52    CannotSaveWhenInMemoryConfig,
53    WalletNotFound,
54    WalletAlreadyAdded,
55    WalletAlreadyOpened,
56    WalletError(String),
57    BrokerError,
58    SessionNotFound,
59    SessionAlreadyStarted,
60    RepoNotFound,
61    BranchNotFound,
62    StoreNotFound,
63    UserNotFound,
64    TopicNotFound,
65    NotConnected,
66    ActorError,
67    ProtocolError(ProtocolError),
68    ServerError(ServerError),
69    InvalidResponse,
70    BootstrapError(String),
71    NotAServerError,
72    VerifierError(VerifierError),
73    SiteNotFoundOnBroker,
74    BrokerConfigErrorStr(&'static str),
75    BrokerConfigError(String),
76    MalformedEvent,
77    InvalidPayload,
78    WrongUploadId,
79    FileError(FileError),
80    InternalError,
81    OxiGraphError(String),
82    ConfigError(String),
83    LocalBrokerIsHeadless,
84    LocalBrokerIsNotHeadless,
85    InvalidNuri,
86    InvalidTarget,
87    InvalidQrCode,
88    NotImplemented,
89    NotARendezVous,
90    IncompatibleQrCode,
91    InvalidClass,
92    KeyShareNotFound,
93    BrokerNotFound,
94}
95
96impl Error for NgError {}
97
98impl fmt::Display for NgError {
99    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
100        match self {
101            Self::WalletError(string) => write!(f, "WalletError:{}", string),
102            Self::JsStorageWriteError(string) => write!(f, "JsStorageWriteError:{}", string),
103            Self::CommitVerifyError(commit_verify_error) => {
104                write!(f, "CommitVerifyError:{:?}", commit_verify_error)
105            }
106            Self::ProtocolError(error) => write!(f, "ProtocolError:{:?}", error),
107            Self::ServerError(error) => write!(f, "ServerError:{:?}", error),
108            Self::VerifierError(error) => write!(f, "VerifierError:{:?}", error),
109            Self::CommitLoadError(commit_load_error) => {
110                write!(f, "CommitLoadError:{:?}", commit_load_error)
111            }
112            Self::BootstrapError(error) => {
113                write!(f, "BootstrapError:{:?}", error)
114            }
115            Self::ObjectParseError(error) => write!(f, "ObjectParseError:{:?}", error),
116            Self::StorageError(storage_error) => write!(f, "StorageError:{:?}", storage_error),
117            Self::BrokerConfigErrorStr(s) => write!(f, "BrokerConfigError:{s}"),
118            Self::BrokerConfigError(s) => write!(f, "BrokerConfigError:{s}"),
119            _ => write!(f, "{:?}", self),
120        }
121    }
122}
123
124impl From<NgError> for std::io::Error {
125    fn from(err: NgError) -> std::io::Error {
126        match err {
127            NgError::InvalidArgument => std::io::Error::from(std::io::ErrorKind::InvalidInput),
128            NgError::PermissionDenied => std::io::Error::from(std::io::ErrorKind::PermissionDenied),
129            NgError::NotFound => std::io::Error::from(std::io::ErrorKind::NotFound),
130            _ => std::io::Error::new(std::io::ErrorKind::Other, err.to_string().as_str()),
131        }
132    }
133}
134
135impl From<serde_bare::error::Error> for NgError {
136    fn from(_e: serde_bare::error::Error) -> Self {
137        NgError::SerializationError
138    }
139}
140
141impl From<ed25519_dalek::ed25519::Error> for NgError {
142    fn from(_e: ed25519_dalek::ed25519::Error) -> Self {
143        NgError::InvalidSignature
144    }
145}
146
147impl From<CommitLoadError> for NgError {
148    fn from(e: CommitLoadError) -> Self {
149        NgError::CommitLoadError(e)
150    }
151}
152
153impl From<ObjectParseError> for NgError {
154    fn from(e: ObjectParseError) -> Self {
155        NgError::ObjectParseError(e)
156    }
157}
158
159impl From<FileError> for NgError {
160    fn from(e: FileError) -> Self {
161        NgError::FileError(e)
162    }
163}
164
165impl From<CommitVerifyError> for NgError {
166    fn from(e: CommitVerifyError) -> Self {
167        NgError::CommitVerifyError(e)
168    }
169}
170
171impl From<StorageError> for NgError {
172    fn from(e: StorageError) -> Self {
173        NgError::StorageError(e)
174    }
175}
176
177impl From<VerifierError> for NgError {
178    fn from(e: VerifierError) -> Self {
179        match e {
180            VerifierError::InvalidKey => NgError::InvalidKey,
181            VerifierError::SerializationError => NgError::SerializationError,
182            VerifierError::CommitLoadError(e) => NgError::CommitLoadError(e),
183            VerifierError::StorageError(e) => NgError::StorageError(e),
184            VerifierError::ObjectParseError(e) => NgError::ObjectParseError(e),
185            VerifierError::TopicNotFound => NgError::TopicNotFound,
186            VerifierError::RepoNotFound => NgError::RepoNotFound,
187            VerifierError::StoreNotFound => NgError::StoreNotFound,
188            VerifierError::BranchNotFound => NgError::BranchNotFound,
189            _ => NgError::VerifierError(e),
190        }
191    }
192}
193
194/// Object parsing errors
195#[derive(Debug, PartialEq, Eq, Clone)]
196pub enum ObjectParseError {
197    /// Missing blocks
198    MissingBlocks(Vec<BlockId>),
199    /// Missing root key
200    MissingRootKey,
201    /// Invalid BlockId encountered in the tree
202    InvalidBlockId,
203    /// Too many or too few children of a block
204    InvalidChildren,
205    /// Number of keys does not match number of children of a block
206    InvalidKeys,
207    /// Invalid CommitHeader object content
208    InvalidHeader,
209    /// Error deserializing content of a block
210    BlockDeserializeError,
211    /// Error deserializing content of the object
212    ObjectDeserializeError,
213
214    MissingHeaderBlocks((Object, Vec<BlockId>)),
215
216    MalformedDag,
217    FilterDeserializationError,
218}
219
220#[derive(Debug, PartialEq, Eq, Clone)]
221pub enum StorageError {
222    NotFound,
223    InvalidValue,
224    DifferentValue,
225    BackendError,
226    SerializationError,
227    AlreadyExists,
228    DataCorruption,
229    UnknownColumnFamily,
230    PropertyNotFound,
231    NotAStoreRepo,
232    OverlayBranchNotFound,
233    Abort,
234    NotEmpty,
235    ServerAlreadyRunningInOtherProcess,
236    NgError(String),
237    NoDiscreteState,
238}
239
240impl core::fmt::Display for StorageError {
241    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
242        write!(f, "{:?}", self)
243    }
244}
245
246impl From<serde_bare::error::Error> for StorageError {
247    fn from(_e: serde_bare::error::Error) -> Self {
248        StorageError::SerializationError
249    }
250}
251
252impl From<NgError> for StorageError {
253    fn from(e: NgError) -> Self {
254        StorageError::NgError(e.to_string())
255    }
256}
257
258#[derive(Debug, Eq, PartialEq, TryFromPrimitive, IntoPrimitive, Clone)]
259#[repr(u16)]
260pub enum ServerError {
261    Ok = 0,
262    PartialContent,
263    EndOfStream,
264    False,
265    SequenceMismatch,
266    FileError,
267    RepoAlreadyOpened,
268    NotFound,
269    EmptyStream,
270    StorageError,
271    InvalidRequest,
272    InvalidSignature,
273    OtherError,
274    OverlayMismatch,
275    OverlayNotFound,
276    TopicNotFound,
277    AccessDenied,
278    InvalidHeader,
279    MalformedBranch,
280    BrokerError,
281    ProtocolError,
282    PeerAlreadySubscribed,
283    SubscriptionNotFound,
284    SessionNotFound,
285    SessionDetached,
286    OxiGraphError,
287    InvalidNuri,
288    InvalidTarget,
289    ExportWalletTimeOut,
290    NetError,
291}
292
293impl From<StorageError> for ServerError {
294    fn from(e: StorageError) -> Self {
295        match e {
296            StorageError::NotFound => ServerError::NotFound,
297            _ => ServerError::StorageError,
298        }
299    }
300}
301
302impl From<NetError> for ServerError {
303    fn from(e: NetError) -> Self {
304        match e {
305            _ => ServerError::NetError,
306        }
307    }
308}
309
310impl From<ProtocolError> for ServerError {
311    fn from(e: ProtocolError) -> Self {
312        match e {
313            ProtocolError::NotFound => ServerError::NotFound,
314            ProtocolError::BrokerError => ServerError::BrokerError,
315            _ => {
316                log_err!("{:?}", e);
317                ServerError::ProtocolError
318            }
319        }
320    }
321}
322
323impl From<NgError> for ServerError {
324    fn from(e: NgError) -> Self {
325        match e {
326            NgError::InvalidSignature => ServerError::InvalidSignature,
327            NgError::OxiGraphError(_) => ServerError::OxiGraphError,
328            NgError::InvalidNuri => ServerError::InvalidNuri,
329            NgError::InvalidTarget => ServerError::InvalidTarget,
330
331            _ => ServerError::OtherError,
332        }
333    }
334}
335
336impl ServerError {
337    pub fn is_stream(&self) -> bool {
338        *self == ServerError::PartialContent || *self == ServerError::EndOfStream
339    }
340    pub fn is_err(&self) -> bool {
341        *self != ServerError::Ok && !self.is_stream()
342    }
343}
344
345#[derive(Debug, Eq, PartialEq, Clone)]
346pub enum VerifierError {
347    MalformedDag,
348    MissingCommitInDag,
349    CommitBodyNotFound,
350    InvalidKey,
351    SerializationError,
352    OtherError(String),
353    CommitLoadError(CommitLoadError),
354    InvalidRepositoryCommit,
355    MissingRepoWriteCapSecret,
356    StorageError(StorageError),
357    ObjectParseError(ObjectParseError),
358    NotImplemented,
359    InvalidSignatureObject,
360    MalformedSyncSignatureAcks,
361    MalformedSyncSignatureDeps,
362    TopicNotFound,
363    RepoNotFound,
364    StoreNotFound,
365    OverlayNotFound,
366    BranchNotFound,
367    InvalidBranch,
368    NoBlockStorageAvailable,
369    RootBranchNotFound,
370    BranchNotOpened,
371    DoubleBranchSubscription,
372    InvalidCommit,
373    LocallyConnected,
374    InvalidTriple,
375    InvalidNamedGraph,
376    OxigraphError(String),
377    CannotRemoveTriplesWhenNewBranch,
378    PermissionDenied,
379    YrsError(String),
380    AutomergeError(String),
381    InvalidNuri,
382    InvalidJson,
383    NothingToSign,
384}
385
386impl Error for VerifierError {}
387
388impl core::fmt::Display for VerifierError {
389    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
390        write!(f, "{:?}", self)
391    }
392}
393
394impl From<serde_bare::error::Error> for VerifierError {
395    fn from(_e: serde_bare::error::Error) -> Self {
396        VerifierError::SerializationError
397    }
398}
399
400impl From<NgError> for VerifierError {
401    fn from(e: NgError) -> Self {
402        match e {
403            NgError::InvalidKey => VerifierError::InvalidKey,
404            NgError::RepoNotFound => VerifierError::RepoNotFound,
405            NgError::BranchNotFound => VerifierError::BranchNotFound,
406            NgError::SerializationError => VerifierError::SerializationError,
407            NgError::PermissionDenied => VerifierError::PermissionDenied,
408            NgError::VerifierError(e) => e,
409            // NgError::JsStorageReadError
410            // NgError::JsStorageWriteError(String)
411            // NgError::JsStorageKeyNotFound
412            // NgError::InvalidFileFormat
413            _ => VerifierError::OtherError(e.to_string()),
414        }
415    }
416}
417
418impl From<CommitLoadError> for VerifierError {
419    fn from(e: CommitLoadError) -> Self {
420        VerifierError::CommitLoadError(e)
421    }
422}
423
424impl From<ObjectParseError> for VerifierError {
425    fn from(e: ObjectParseError) -> Self {
426        VerifierError::ObjectParseError(e)
427    }
428}
429
430impl From<StorageError> for VerifierError {
431    fn from(e: StorageError) -> Self {
432        VerifierError::StorageError(e)
433    }
434}
435
436#[derive(Debug, Eq, PartialEq, TryFromPrimitive, IntoPrimitive, Clone)]
437#[repr(u16)]
438pub enum NetError {
439    DirectionAlreadySet = 1,
440    WsError,
441    IoError,
442    ConnectionError,
443    SerializationError,
444    ProtocolError,
445    AccessDenied,
446    InternalError,
447    PeerAlreadyConnected,
448    Closing,
449} //MAX 50 NetErrors
450
451impl Error for NetError {}
452
453impl fmt::Display for NetError {
454    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
455        write!(f, "{:?}", self)
456    }
457}
458
459#[derive(Debug, Eq, PartialEq, TryFromPrimitive, IntoPrimitive, Clone)]
460#[repr(u16)]
461pub enum ProtocolError {
462    NoError = 0,
463
464    IoError,
465    WsError,
466    ActorError,
467    InvalidState,
468    InvalidSignature,
469    SerializationError,
470    AccessDenied,
471    InvitationRequired,
472    BrokerError,
473    NoLocalBrokerFound,
474    NotFound,
475    MissingBlocks,
476    ObjectParseError,
477    InvalidValue,
478    AlreadyExists,
479    RepoIdRequired,
480    InvalidPublisherAdvert,
481
482    ConnectionError,
483    Timeout,
484    Expired,
485
486    PeerAlreadyConnected,
487    UserNotConnected,
488    PeerNotConnected,
489    OtherError,
490    NetError,
491    StorageError,
492    ServerError,
493    Closing,
494    FsmNotReady,
495    MustBeEncrypted,
496    NoiseHandshakeFailed,
497    DecryptionError,
498    EncryptionError,
499    WhereIsTheMagic,
500
501    InvalidNonce,
502    InvalidMessage,
503} //MAX 949 ProtocolErrors
504
505impl From<NetError> for ProtocolError {
506    fn from(e: NetError) -> Self {
507        match e {
508            NetError::IoError => ProtocolError::IoError,
509            NetError::WsError => ProtocolError::WsError,
510            NetError::ConnectionError => ProtocolError::ConnectionError,
511            NetError::SerializationError => ProtocolError::SerializationError,
512            NetError::ProtocolError => ProtocolError::OtherError,
513            NetError::AccessDenied => ProtocolError::AccessDenied,
514            NetError::PeerAlreadyConnected => ProtocolError::PeerAlreadyConnected,
515            NetError::Closing => ProtocolError::Closing,
516            _ => ProtocolError::NetError,
517        }
518    }
519}
520
521impl From<StorageError> for ProtocolError {
522    fn from(e: StorageError) -> Self {
523        match e {
524            StorageError::NotFound => ProtocolError::NotFound,
525            StorageError::InvalidValue => ProtocolError::InvalidValue,
526            StorageError::BackendError => ProtocolError::StorageError,
527            StorageError::SerializationError => ProtocolError::SerializationError,
528            StorageError::AlreadyExists => ProtocolError::AlreadyExists,
529            _ => ProtocolError::StorageError,
530        }
531    }
532}
533
534impl From<ProtocolError> for NgError {
535    fn from(e: ProtocolError) -> Self {
536        NgError::ProtocolError(e)
537    }
538}
539
540impl From<ServerError> for NgError {
541    fn from(e: ServerError) -> Self {
542        NgError::ServerError(e)
543    }
544}
545
546impl ProtocolError {
547    pub fn is_err(&self) -> bool {
548        *self != ProtocolError::NoError
549    }
550}
551
552impl Error for ProtocolError {}
553
554impl fmt::Display for ProtocolError {
555    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
556        write!(f, "{:?}", self)
557    }
558}
559
560impl From<NgError> for ProtocolError {
561    fn from(e: NgError) -> Self {
562        match e {
563            NgError::InvalidSignature => ProtocolError::InvalidSignature,
564            NgError::SerializationError => ProtocolError::SerializationError,
565            _ => ProtocolError::OtherError,
566        }
567    }
568}
569
570impl From<ObjectParseError> for ProtocolError {
571    fn from(_e: ObjectParseError) -> Self {
572        ProtocolError::ObjectParseError
573    }
574}
575
576impl From<serde_bare::error::Error> for ProtocolError {
577    fn from(_e: serde_bare::error::Error) -> Self {
578        ProtocolError::SerializationError
579    }
580}
581
582impl From<serde_bare::error::Error> for NetError {
583    fn from(_e: serde_bare::error::Error) -> Self {
584        NetError::SerializationError
585    }
586}
ng_repo/errors.rs

ng_repo/
errors.rs
