Method open

src/darkbird/storage.rs:61–105

(ops: Options<'a>)

        + 'static,
{
    pub async fn open<'a>(ops: Options<'a>) -> Result<Self, String> {
        
        match DiskLog::open(ops.path, ops.storage_name, ops.total_page_size) {
            Err(e) => return Err(e.to_string()),
            Ok(disklog) => {
                // Run DiskLog
                let off_disk = if let StorageType::RamCopies = ops.stype { true } else { false };

                // Run Reporter
                let reporter = Router::<Event<K, Doc>>::new(vec![]).unwrap().run_service();

                // Run disk_log
                let wal_session = disklog.run_service();


                // Create Storage
                let mut st = Storage {
                    collection: DashMap::new(),
                    hash_index: HashIndex::new(),
                    tag_index: TagIndex::new(),
                    range_index: RangeIndex::new(),
                    inverted_index: InvertedIndex::new(),
                    wal_session: wal_session,
                    reporter_session: reporter,
                    off_reporter: ops.off_reporter,
                    off_disk: true
                };


                // load from disk
                if let Err(x) = st.loader().await {
                    if x != "End" {
                        return Err(x);
                    } 
                }


                // because we want loader dont write to disk_log
                st.off_disk = off_disk;

                return Ok(st);
            }
        }

    }

    /// subscribe to Reporter
    #[inline]