Struct mailpot::Error

source ·

pub struct Error(pub ErrorKind, _);

Expand description

The Error type.

This tuple struct is made of two elements:

an ErrorKind which is used to determine the type of the error.
An internal State, not meant for direct use outside of error_chain internals, containing:
- a backtrace, generated when the error is created.
- an error chain, used for the implementation of Error::cause().

Tuple Fields§

§0: ErrorKind

The kind of the error.

Implementations§

source §

impl Error

source

pub fn from_kind(kind: ErrorKind) -> Error

Constructs an error from a kind, and generates a backtrace.

source

pub fn with_chain<E, K>(error: E, kind: K) -> Errorwhere E: Error + Send + 'static, K: Into<ErrorKind>,

Constructs a chained error from another error and a kind, and generates a backtrace.

source

pub fn with_boxed_chain<K>(error: Box<dyn Error + Send>, kind: K) -> Errorwhere K: Into<ErrorKind>,

Construct a chained error from another boxed error and a kind, and generates a backtrace

source

pub fn kind(&self) -> &ErrorKind

Returns the kind of the error.

source

pub fn iter(&self) -> Iter<'_>

Iterates over the error chain.

source

pub fn backtrace(&self) -> Option<&Backtrace>

Returns the backtrace associated with this error.

source

pub fn chain_err<F, EK>(self, error: F) -> Errorwhere F: FnOnce() -> EK, EK: Into<ErrorKind>,

Extends the error chain with a new entry.

Examples found in repository ?

core/src/connection.rs (line 617)

    pub fn remove_list_owner(&self, list_pk: i64, owner_pk: i64) -> Result<()> {
        self.connection
            .query_row(
                "DELETE FROM owner WHERE list = ? AND pk = ? RETURNING *;",
                rusqlite::params![&list_pk, &owner_pk],
                |_| Ok(()),
            )
            .map_err(|err| {
                if matches!(err, rusqlite::Error::QueryReturnedNoRows) {
                    Error::from(err).chain_err(|| NotFound("list or list owner not found!"))
                } else {
                    err.into()
                }
            })?;
        Ok(())
    }

    /// Add an owner of a mailing list.
    pub fn add_list_owner(&self, list_owner: ListOwner) -> Result<DbVal<ListOwner>> {
        let mut stmt = self.connection.prepare(
            "INSERT OR REPLACE INTO owner(list, address, name) VALUES (?, ?, ?) RETURNING *;",
        )?;
        let list_pk = list_owner.list;
        let ret = stmt
            .query_row(
                rusqlite::params![&list_pk, &list_owner.address, &list_owner.name,],
                |row| {
                    let pk = row.get("pk")?;
                    Ok(DbVal(
                        ListOwner {
                            pk,
                            list: row.get("list")?,
                            address: row.get("address")?,
                            name: row.get("name")?,
                        },
                        pk,
                    ))
                },
            )
            .map_err(|err| {
                if matches!(
                    err,
                    rusqlite::Error::SqliteFailure(
                        rusqlite::ffi::Error {
                            code: rusqlite::ffi::ErrorCode::ConstraintViolation,
                            extended_code: 787
                        },
                        _
                    )
                ) {
                    Error::from(err).chain_err(|| NotFound("Could not find a list with this pk."))
                } else {
                    err.into()
                }
            })?;

        trace!("add_list_owner {:?}.", &ret);
        Ok(ret)
    }

More examples

Hide additional examples

core/src/policies.rs (line 139)

        pub fn remove_list_post_policy(&self, list_pk: i64, policy_pk: i64) -> Result<()> {
            let mut stmt = self
                .connection
                .prepare("DELETE FROM post_policy WHERE pk = ? AND list = ? RETURNING *;")?;
            stmt.query_row(rusqlite::params![&policy_pk, &list_pk,], |_| Ok(()))
                .map_err(|err| {
                    if matches!(err, rusqlite::Error::QueryReturnedNoRows) {
                        Error::from(err).chain_err(|| NotFound("list or list policy not found!"))
                    } else {
                        err.into()
                    }
                })?;

            trace!("remove_list_post_policy {} {}.", list_pk, policy_pk);
            Ok(())
        }

        /// Set the unique post policy for a list.
        pub fn set_list_post_policy(&self, policy: PostPolicy) -> Result<DbVal<PostPolicy>> {
            if !(policy.announce_only
                || policy.subscription_only
                || policy.approval_needed
                || policy.open
                || policy.custom)
            {
                return Err(
                    "Cannot add empty policy. Having no policies is probably what you want to do."
                        .into(),
                );
            }
            let list_pk = policy.list;

            let mut stmt = self.connection.prepare(
                "INSERT OR REPLACE INTO post_policy(list, announce_only, subscription_only, \
                 approval_needed, open, custom) VALUES (?, ?, ?, ?, ?, ?) RETURNING *;",
            )?;
            let ret = stmt
                .query_row(
                    rusqlite::params![
                        &list_pk,
                        &policy.announce_only,
                        &policy.subscription_only,
                        &policy.approval_needed,
                        &policy.open,
                        &policy.custom,
                    ],
                    |row| {
                        let pk = row.get("pk")?;
                        Ok(DbVal(
                            PostPolicy {
                                pk,
                                list: row.get("list")?,
                                announce_only: row.get("announce_only")?,
                                subscription_only: row.get("subscription_only")?,
                                approval_needed: row.get("approval_needed")?,
                                open: row.get("open")?,
                                custom: row.get("custom")?,
                            },
                            pk,
                        ))
                    },
                )
                .map_err(|err| {
                    if matches!(
                        err,
                        rusqlite::Error::SqliteFailure(
                            rusqlite::ffi::Error {
                                code: rusqlite::ffi::ErrorCode::ConstraintViolation,
                                extended_code: 787
                            },
                            _
                        )
                    ) {
                        Error::from(err)
                            .chain_err(|| NotFound("Could not find a list with this pk."))
                    } else {
                        err.into()
                    }
                })?;

            trace!("set_list_post_policy {:?}.", &ret);
            Ok(ret)
        }
    }
}

mod subscription_policy {
    use log::trace;
    use rusqlite::OptionalExtension;

    use crate::{
        errors::{ErrorKind::*, *},
        models::{DbVal, SubscriptionPolicy},
        Connection,
    };

    impl Connection {
        /// Fetch the subscription policy of a mailing list.
        pub fn list_subscription_policy(
            &self,
            pk: i64,
        ) -> Result<Option<DbVal<SubscriptionPolicy>>> {
            let mut stmt = self
                .connection
                .prepare("SELECT * FROM subscription_policy WHERE list = ?;")?;
            let ret = stmt
                .query_row([&pk], |row| {
                    let pk = row.get("pk")?;
                    Ok(DbVal(
                        SubscriptionPolicy {
                            pk,
                            list: row.get("list")?,
                            send_confirmation: row.get("send_confirmation")?,
                            open: row.get("open")?,
                            manual: row.get("manual")?,
                            request: row.get("request")?,
                            custom: row.get("custom")?,
                        },
                        pk,
                    ))
                })
                .optional()?;

            Ok(ret)
        }

        /// Remove an existing subscription policy.
        ///
        /// # Examples
        ///
        /// ```
        /// # use mailpot::{models::*, Configuration, Connection, SendMail};
        /// # use tempfile::TempDir;
        /// #
        /// # let tmp_dir = TempDir::new().unwrap();
        /// # let db_path = tmp_dir.path().join("mpot.db");
        /// # let config = Configuration {
        /// #     send_mail: SendMail::ShellCommand("/usr/bin/false".to_string()),
        /// #     db_path: db_path.clone(),
        /// #     data_path: tmp_dir.path().to_path_buf(),
        /// #     administrators: vec![],
        /// # };
        /// #
        /// # fn do_test(config: Configuration) {
        /// let db = Connection::open_or_create_db(config).unwrap().trusted();
        /// let list = db
        ///     .create_list(MailingList {
        ///         pk: 0,
        ///         name: "foobar chat".into(),
        ///         id: "foo-chat".into(),
        ///         address: "foo-chat@example.com".into(),
        ///         description: None,
        ///         topics: vec![],
        ///         archive_url: None,
        ///     })
        ///     .unwrap();
        /// # assert!(db.list_subscription_policy(list.pk()).unwrap().is_none());
        /// let pol = db
        ///     .set_list_subscription_policy(SubscriptionPolicy {
        ///         pk: -1,
        ///         list: list.pk(),
        ///         send_confirmation: false,
        ///         open: true,
        ///         manual: false,
        ///         request: false,
        ///         custom: false,
        ///     })
        ///     .unwrap();
        /// # assert_eq!(db.list_subscription_policy(list.pk()).unwrap().as_ref(), Some(&pol));
        /// db.remove_list_subscription_policy(list.pk(), pol.pk())
        ///     .unwrap();
        /// # assert!(db.list_subscription_policy(list.pk()).unwrap().is_none());
        /// # }
        /// # do_test(config);
        /// ```
        ///
        /// ```should_panic
        /// # use mailpot::{models::*, Configuration, Connection, SendMail};
        /// # use tempfile::TempDir;
        /// #
        /// # let tmp_dir = TempDir::new().unwrap();
        /// # let db_path = tmp_dir.path().join("mpot.db");
        /// # let config = Configuration {
        /// #     send_mail: SendMail::ShellCommand("/usr/bin/false".to_string()),
        /// #     db_path: db_path.clone(),
        /// #     data_path: tmp_dir.path().to_path_buf(),
        /// #     administrators: vec![],
        /// # };
        /// #
        /// # fn do_test(config: Configuration) {
        /// let db = Connection::open_or_create_db(config).unwrap().trusted();
        /// db.remove_list_post_policy(1, 1).unwrap();
        /// # }
        /// # do_test(config);
        /// ```
        pub fn remove_list_subscription_policy(&self, list_pk: i64, policy_pk: i64) -> Result<()> {
            let mut stmt = self.connection.prepare(
                "DELETE FROM subscription_policy WHERE pk = ? AND list = ? RETURNING *;",
            )?;
            stmt.query_row(rusqlite::params![&policy_pk, &list_pk,], |_| Ok(()))
                .map_err(|err| {
                    if matches!(err, rusqlite::Error::QueryReturnedNoRows) {
                        Error::from(err).chain_err(|| NotFound("list or list policy not found!"))
                    } else {
                        err.into()
                    }
                })?;

            trace!("remove_list_subscription_policy {} {}.", list_pk, policy_pk);
            Ok(())
        }

        /// Set the unique post policy for a list.
        pub fn set_list_subscription_policy(
            &self,
            policy: SubscriptionPolicy,
        ) -> Result<DbVal<SubscriptionPolicy>> {
            if !(policy.open || policy.manual || policy.request || policy.custom) {
                return Err(
                    "Cannot add empty policy. Having no policy is probably what you want to do."
                        .into(),
                );
            }
            let list_pk = policy.list;

            let mut stmt = self.connection.prepare(
                "INSERT OR REPLACE INTO subscription_policy(list, send_confirmation, open, \
                 manual, request, custom) VALUES (?, ?, ?, ?, ?, ?) RETURNING *;",
            )?;
            let ret = stmt
                .query_row(
                    rusqlite::params![
                        &list_pk,
                        &policy.send_confirmation,
                        &policy.open,
                        &policy.manual,
                        &policy.request,
                        &policy.custom,
                    ],
                    |row| {
                        let pk = row.get("pk")?;
                        Ok(DbVal(
                            SubscriptionPolicy {
                                pk,
                                list: row.get("list")?,
                                send_confirmation: row.get("send_confirmation")?,
                                open: row.get("open")?,
                                manual: row.get("manual")?,
                                request: row.get("request")?,
                                custom: row.get("custom")?,
                            },
                            pk,
                        ))
                    },
                )
                .map_err(|err| {
                    if matches!(
                        err,
                        rusqlite::Error::SqliteFailure(
                            rusqlite::ffi::Error {
                                code: rusqlite::ffi::ErrorCode::ConstraintViolation,
                                extended_code: 787
                            },
                            _
                        )
                    ) {
                        Error::from(err)
                            .chain_err(|| NotFound("Could not find a list with this pk."))
                    } else {
                        err.into()
                    }
                })?;

            trace!("set_list_subscription_policy {:?}.", &ret);
            Ok(ret)
        }

core/src/posts.rs (line 115)

    pub fn post(&self, env: &Envelope, raw: &[u8], _dry_run: bool) -> Result<()> {
        let result = self.inner_post(env, raw, _dry_run);
        if let Err(err) = result {
            return match self.insert_to_queue(QueueEntry::new(
                Queue::Error,
                None,
                Some(Cow::Borrowed(env)),
                raw,
                Some(err.to_string()),
            )?) {
                Ok(idx) => {
                    log::info!(
                        "Inserted mail from {:?} into error_queue at index {}",
                        env.from(),
                        idx
                    );
                    Err(err)
                }
                Err(err2) => {
                    log::error!(
                        "Could not insert mail from {:?} into error_queue: {err2}",
                        env.from(),
                    );

                    Err(err.chain_err(|| err2))
                }
            };
        }
        result
    }

core/src/subscriptions.rs (line 246)

    pub fn candidate_subscription(&self, pk: i64) -> Result<DbVal<ListCandidateSubscription>> {
        let mut stmt = self
            .connection
            .prepare("SELECT * FROM candidate_subscription WHERE pk = ?;")?;
        let val = stmt
            .query_row(rusqlite::params![&pk], |row| {
                let _pk: i64 = row.get("pk")?;
                debug_assert_eq!(pk, _pk);
                Ok(DbVal(
                    ListCandidateSubscription {
                        pk,
                        list: row.get("list")?,
                        address: row.get("address")?,
                        name: row.get("name")?,
                        accepted: row.get("accepted")?,
                    },
                    pk,
                ))
            })
            .map_err(|err| {
                if matches!(err, rusqlite::Error::QueryReturnedNoRows) {
                    Error::from(err)
                        .chain_err(|| NotFound("Candidate subscription with this pk not found!"))
                } else {
                    err.into()
                }
            })?;

        Ok(val)
    }

    /// Accept subscription candidate.
    pub fn accept_candidate_subscription(&self, pk: i64) -> Result<DbVal<ListSubscription>> {
        let val = self.connection.query_row(
            "INSERT INTO subscription(list, address, name, enabled, digest, verified, \
             hide_address, receive_duplicates, receive_own_posts, receive_confirmation) SELECT \
             list, address, name, 1, 0, 0, 0, 1, 1, 0 FROM candidate_subscription WHERE pk = ? \
             RETURNING *;",
            rusqlite::params![&pk],
            |row| {
                let pk = row.get("pk")?;
                Ok(DbVal(
                    ListSubscription {
                        pk,
                        list: row.get("list")?,
                        address: row.get("address")?,
                        account: row.get("account")?,
                        name: row.get("name")?,
                        digest: row.get("digest")?,
                        enabled: row.get("enabled")?,
                        verified: row.get("verified")?,
                        hide_address: row.get("hide_address")?,
                        receive_duplicates: row.get("receive_duplicates")?,
                        receive_own_posts: row.get("receive_own_posts")?,
                        receive_confirmation: row.get("receive_confirmation")?,
                    },
                    pk,
                ))
            },
        )?;

        trace!("accept_candidate_subscription {:?}.", &val);
        // table entry might be modified by triggers, so don't rely on RETURNING value.
        let ret = self.list_subscription(val.list, val.pk())?;

        // assert that [ref:accept_candidate] trigger works.
        debug_assert_eq!(Some(ret.pk), self.candidate_subscription(pk)?.accepted);
        Ok(ret)
    }

    /// Remove a subscription by their address.
    pub fn remove_subscription(&self, list_pk: i64, address: &str) -> Result<()> {
        self.connection
            .query_row(
                "DELETE FROM subscription WHERE list = ? AND address = ? RETURNING *;",
                rusqlite::params![&list_pk, &address],
                |_| Ok(()),
            )
            .map_err(|err| {
                if matches!(err, rusqlite::Error::QueryReturnedNoRows) {
                    Error::from(err).chain_err(|| NotFound("list or list owner not found!"))
                } else {
                    err.into()
                }
            })?;

        Ok(())
    }

    /// Update a mailing list subscription.
    pub fn update_subscription(&self, change_set: ListSubscriptionChangeset) -> Result<()> {
        let pk = self
            .list_subscription_by_address(change_set.list, &change_set.address)?
            .pk;
        if matches!(
            change_set,
            ListSubscriptionChangeset {
                list: _,
                address: _,
                account: None,
                name: None,
                digest: None,
                verified: None,
                hide_address: None,
                receive_duplicates: None,
                receive_own_posts: None,
                receive_confirmation: None,
                enabled: None,
            }
        ) {
            return Ok(());
        }

        let ListSubscriptionChangeset {
            list,
            address: _,
            name,
            account,
            digest,
            enabled,
            verified,
            hide_address,
            receive_duplicates,
            receive_own_posts,
            receive_confirmation,
        } = change_set;
        let tx = self.savepoint(Some(stringify!(update_subscription)))?;

        macro_rules! update {
            ($field:tt) => {{
                if let Some($field) = $field {
                    tx.connection.execute(
                        concat!(
                            "UPDATE subscription SET ",
                            stringify!($field),
                            " = ? WHERE list = ? AND pk = ?;"
                        ),
                        rusqlite::params![&$field, &list, &pk],
                    )?;
                }
            }};
        }
        update!(name);
        update!(account);
        update!(digest);
        update!(enabled);
        update!(verified);
        update!(hide_address);
        update!(receive_duplicates);
        update!(receive_own_posts);
        update!(receive_confirmation);

        tx.commit()?;
        Ok(())
    }

    /// Fetch account by pk.
    pub fn account(&self, pk: i64) -> Result<Option<DbVal<Account>>> {
        let mut stmt = self
            .connection
            .prepare("SELECT * FROM account WHERE pk = ?;")?;

        let ret = stmt
            .query_row(rusqlite::params![&pk], |row| {
                let _pk: i64 = row.get("pk")?;
                debug_assert_eq!(pk, _pk);
                Ok(DbVal(
                    Account {
                        pk,
                        name: row.get("name")?,
                        address: row.get("address")?,
                        public_key: row.get("public_key")?,
                        password: row.get("password")?,
                        enabled: row.get("enabled")?,
                    },
                    pk,
                ))
            })
            .optional()?;
        Ok(ret)
    }

    /// Fetch account by address.
    pub fn account_by_address(&self, address: &str) -> Result<Option<DbVal<Account>>> {
        let mut stmt = self
            .connection
            .prepare("SELECT * FROM account WHERE address = ?;")?;

        let ret = stmt
            .query_row(rusqlite::params![&address], |row| {
                let pk = row.get("pk")?;
                Ok(DbVal(
                    Account {
                        pk,
                        name: row.get("name")?,
                        address: row.get("address")?,
                        public_key: row.get("public_key")?,
                        password: row.get("password")?,
                        enabled: row.get("enabled")?,
                    },
                    pk,
                ))
            })
            .optional()?;
        Ok(ret)
    }

    /// Fetch all subscriptions of an account by primary key.
    pub fn account_subscriptions(&self, pk: i64) -> Result<Vec<DbVal<ListSubscription>>> {
        let mut stmt = self
            .connection
            .prepare("SELECT * FROM subscription WHERE account = ?;")?;
        let list_iter = stmt.query_map([&pk], |row| {
            let pk = row.get("pk")?;
            Ok(DbVal(
                ListSubscription {
                    pk: row.get("pk")?,
                    list: row.get("list")?,
                    address: row.get("address")?,
                    account: row.get("account")?,
                    name: row.get("name")?,
                    digest: row.get("digest")?,
                    enabled: row.get("enabled")?,
                    verified: row.get("verified")?,
                    hide_address: row.get("hide_address")?,
                    receive_duplicates: row.get("receive_duplicates")?,
                    receive_own_posts: row.get("receive_own_posts")?,
                    receive_confirmation: row.get("receive_confirmation")?,
                },
                pk,
            ))
        })?;

        let mut ret = vec![];
        for list in list_iter {
            let list = list?;
            ret.push(list);
        }
        Ok(ret)
    }

    /// Fetch all accounts.
    pub fn accounts(&self) -> Result<Vec<DbVal<Account>>> {
        let mut stmt = self
            .connection
            .prepare("SELECT * FROM account ORDER BY pk ASC;")?;
        let list_iter = stmt.query_map([], |row| {
            let pk = row.get("pk")?;
            Ok(DbVal(
                Account {
                    pk,
                    name: row.get("name")?,
                    address: row.get("address")?,
                    public_key: row.get("public_key")?,
                    password: row.get("password")?,
                    enabled: row.get("enabled")?,
                },
                pk,
            ))
        })?;

        let mut ret = vec![];
        for list in list_iter {
            let list = list?;
            ret.push(list);
        }
        Ok(ret)
    }

    /// Add account.
    pub fn add_account(&self, new_val: Account) -> Result<DbVal<Account>> {
        let mut stmt = self
            .connection
            .prepare(
                "INSERT INTO account(name, address, public_key, password, enabled) VALUES(?, ?, \
                 ?, ?, ?) RETURNING *;",
            )
            .unwrap();
        let ret = stmt.query_row(
            rusqlite::params![
                &new_val.name,
                &new_val.address,
                &new_val.public_key,
                &new_val.password,
                &new_val.enabled,
            ],
            |row| {
                let pk = row.get("pk")?;
                Ok(DbVal(
                    Account {
                        pk,
                        name: row.get("name")?,
                        address: row.get("address")?,
                        public_key: row.get("public_key")?,
                        password: row.get("password")?,
                        enabled: row.get("enabled")?,
                    },
                    pk,
                ))
            },
        )?;

        trace!("add_account {:?}.", &ret);
        Ok(ret)
    }

    /// Remove an account by their address.
    pub fn remove_account(&self, address: &str) -> Result<()> {
        self.connection
            .query_row(
                "DELETE FROM account WHERE address = ? RETURNING *;",
                rusqlite::params![&address],
                |_| Ok(()),
            )
            .map_err(|err| {
                if matches!(err, rusqlite::Error::QueryReturnedNoRows) {
                    Error::from(err).chain_err(|| NotFound("account not found!"))
                } else {
                    err.into()
                }
            })?;

        Ok(())
    }

core/src/templates.rs (line 334)

    pub fn add_template(&self, template: Template) -> Result<DbVal<Template>> {
        let mut stmt = self.connection.prepare(
            "INSERT INTO template(name, list, subject, headers_json, body) VALUES(?, ?, ?, ?, ?) \
             RETURNING *;",
        )?;
        let ret = stmt
            .query_row(
                rusqlite::params![
                    &template.name,
                    &template.list,
                    &template.subject,
                    &template.headers_json,
                    &template.body
                ],
                |row| {
                    let pk = row.get("pk")?;
                    Ok(DbVal(
                        Template {
                            pk,
                            name: row.get("name")?,
                            list: row.get("list")?,
                            subject: row.get("subject")?,
                            headers_json: row.get("headers_json")?,
                            body: row.get("body")?,
                        },
                        pk,
                    ))
                },
            )
            .map_err(|err| {
                if matches!(
                    err,
                    rusqlite::Error::SqliteFailure(
                        rusqlite::ffi::Error {
                            code: rusqlite::ffi::ErrorCode::ConstraintViolation,
                            extended_code: 787
                        },
                        _
                    )
                ) {
                    Error::from(err).chain_err(|| NotFound("Could not find a list with this pk."))
                } else {
                    err.into()
                }
            })?;

        trace!("add_template {:?}.", &ret);
        Ok(ret)
    }

source

pub fn description(&self) -> &str

A short description of the error. This method is identical to Error::description()

source §

impl Error

source

pub fn new_external<S: Into<String>>(msg: S) -> Self

Helper function to create a new generic error message.

Examples found in repository ?

core/src/queue.rs (line 65)

    fn from_str(s: &str) -> Result<Self> {
        Ok(match s.trim() {
            s if s.eq_ignore_ascii_case(stringify!(Maildrop)) => Self::Maildrop,
            s if s.eq_ignore_ascii_case(stringify!(Hold)) => Self::Hold,
            s if s.eq_ignore_ascii_case(stringify!(Deferred)) => Self::Deferred,
            s if s.eq_ignore_ascii_case(stringify!(Corrupt)) => Self::Corrupt,
            s if s.eq_ignore_ascii_case(stringify!(Out)) => Self::Out,
            s if s.eq_ignore_ascii_case(stringify!(Error)) => Self::Error,
            other => return Err(Error::new_external(format!("Invalid Queue name: {other}."))),
        })
    }