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
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109

//! An "Env" Combines a database reference with a KeystoreSender

use std::path::Path;

use holochain_keystore::KeystoreSender;
use holochain_sqlite::prelude::*;
use shrinkwraprs::Shrinkwrap;

/// Read access to a database, plus a keystore channel sender
#[derive(Clone, Shrinkwrap)]
pub struct EnvRead {
    #[shrinkwrap(main_field)]
    db: DbRead,
    keystore: KeystoreSender,
}

impl EnvRead {
    /// Accessor
    pub fn keystore(&self) -> &KeystoreSender {
        &self.keystore
    }

    /// Construct from components
    pub fn from_parts(db: DbRead, keystore: KeystoreSender) -> Self {
        Self { db, keystore }
    }
}

/// Write access to a database, plus a keystore channel sender
#[derive(Clone, Shrinkwrap)]
pub struct EnvWrite {
    #[shrinkwrap(main_field)]
    db: DbWrite,
    keystore: KeystoreSender,
}

impl EnvWrite {
    /// Constructor
    pub fn open(path: &Path, kind: DbKind, keystore: KeystoreSender) -> DatabaseResult<Self> {
        Ok(Self {
            db: DbWrite::open(path, kind)?,
            keystore,
        })
    }

    /// Test constructor
    pub fn test(
        tmpdir: &tempdir::TempDir,
        kind: DbKind,
        keystore: KeystoreSender,
    ) -> DatabaseResult<Self> {
        Ok(Self {
            db: DbWrite::test(tmpdir, kind)?,
            keystore,
        })
    }

    /// Kind Accessor
    pub fn kind(&self) -> &DbKind {
        self.db.kind()
    }

    /// Accessor
    pub fn keystore(&self) -> KeystoreSender {
        self.keystore.clone()
    }

    /// Remove the db and directory
    pub async fn remove(self) -> DatabaseResult<()> {
        self.db.remove().await
    }
}

impl From<EnvRead> for DbRead {
    fn from(env: EnvRead) -> DbRead {
        env.db
    }
}

impl From<EnvWrite> for DbWrite {
    fn from(env: EnvWrite) -> DbWrite {
        env.db
    }
}

impl From<EnvWrite> for DbRead {
    fn from(env: EnvWrite) -> DbRead {
        env.db.into()
    }
}

impl From<EnvWrite> for EnvRead {
    fn from(env: EnvWrite) -> EnvRead {
        Self {
            db: env.db.into(),
            keystore: env.keystore,
        }
    }
}

/// FIXME: this ain't right!! But we have had this in the code for a long time.
impl From<EnvRead> for EnvWrite {
    fn from(env: EnvRead) -> EnvWrite {
        Self {
            db: env.db.into(),
            keystore: env.keystore,
        }
    }
}