Initialize tokio once #9

···

       
30
       
 
       
pub struct PdsFs<R> {

     

       
31
       
 
       
    repos: IndexMap<String, Repository<R>>,

     

       
32
       
 
       
    inodes: IndexSet<PdsFsEntry>,

     

       
0
       
 
       

     

       
33
       
 
       
}

     

       
34
       
 
       


     

       
35
       
 
       
#[derive(Debug, Clone, PartialEq, Eq, Hash)]

     
···

       
112
       
 
       
        PdsFs {

     

       
113
       
 
       
            repos: Default::default(),

     

       
114
       
 
       
            inodes: IndexSet::from([PdsFsEntry::Zero, PdsFsEntry::Root]),

     

       
0
       
 
       

     

       
115
       
 
       
        }

     

       
116
       
 
       
    }

     

       
117
       
 
       


     
···

       
185
       
 
       
                let did = self.inodes[col.parent].unwrap_did();

     

       
186
       
 
       
                let repo = &mut self.repos[did];

     

       
187
       
 
       
                let key = format!("{}/{}", col.nsid, r.rkey);

     

       
188
       
-
       
                let rt = tokio::runtime::Runtime::new().unwrap();

     

       
189
       
-
       
                let size = rt

     

       
190
       
 
       
                    .block_on(repo.get_raw::<ipld_core::ipld::Ipld>(&key))

     

       
191
       
 
       
                    .ok()

     

       
192
       
 
       
                    .flatten()

     
···

       
404
       
 
       
        _lock: Option<u64>,

     

       
405
       
 
       
        reply: fuser::ReplyData,

     

       
406
       
 
       
    ) {

     

       
407
       
-
       
        let rt = tokio::runtime::Runtime::new().unwrap();

     

       
408
       
 
       
        if let Some(PdsFsEntry::Record(r)) = self.inodes.get_index(ino as usize) {

     

       
409
       
 
       
            let col = self.inodes[r.parent].unwrap_collection();

     

       
410
       
 
       
            let did = self.inodes[col.parent].unwrap_did();

     

       
411
       
 
       
            let repo = &mut self.repos[did];

     

       
412
       
 
       
            let key = format!("{}/{}", col.nsid, r.rkey);

     

       
413
       
 
       


     

       
414
       
-
       
            if let Ok(Some(val)) = rt.block_on(repo.get_raw::<ipld_core::ipld::Ipld>(&key)) {

     

       
415
       
 
       
                reply.data(&serde_json::to_string_pretty(&val).unwrap().as_bytes()[offset as usize..]);

     

       
416
       
 
       
                return;

     

       
417
       
 
       
            }

     

···

       
30
       
 
       
pub struct PdsFs<R> {

     

       
31
       
 
       
    repos: IndexMap<String, Repository<R>>,

     

       
32
       
 
       
    inodes: IndexSet<PdsFsEntry>,

     

       
33
       
+
       
    rt: tokio::runtime::Runtime,

     

       
34
       
 
       
}

     

       
35
       
 
       


     

       
36
       
 
       
#[derive(Debug, Clone, PartialEq, Eq, Hash)]

     
···

       
113
       
 
       
        PdsFs {

     

       
114
       
 
       
            repos: Default::default(),

     

       
115
       
 
       
            inodes: IndexSet::from([PdsFsEntry::Zero, PdsFsEntry::Root]),

     

       
116
       
+
       
            rt: tokio::runtime::Runtime::new().unwrap(),

     

       
117
       
 
       
        }

     

       
118
       
 
       
    }

     

       
119
       
 
       


     
···

       
187
       
 
       
                let did = self.inodes[col.parent].unwrap_did();

     

       
188
       
 
       
                let repo = &mut self.repos[did];

     

       
189
       
 
       
                let key = format!("{}/{}", col.nsid, r.rkey);

     

       
190
       
+
       
                let size = self

     

       
191
       
+
       
                    .rt

     

       
192
       
 
       
                    .block_on(repo.get_raw::<ipld_core::ipld::Ipld>(&key))

     

       
193
       
 
       
                    .ok()

     

       
194
       
 
       
                    .flatten()

     
···

       
406
       
 
       
        _lock: Option<u64>,

     

       
407
       
 
       
        reply: fuser::ReplyData,

     

       
408
       
 
       
    ) {

     

       
0
       
 
       

     

       
409
       
 
       
        if let Some(PdsFsEntry::Record(r)) = self.inodes.get_index(ino as usize) {

     

       
410
       
 
       
            let col = self.inodes[r.parent].unwrap_collection();

     

       
411
       
 
       
            let did = self.inodes[col.parent].unwrap_did();

     

       
412
       
 
       
            let repo = &mut self.repos[did];

     

       
413
       
 
       
            let key = format!("{}/{}", col.nsid, r.rkey);

     

       
414
       
 
       


     

       
415
       
+
       
            if let Ok(Some(val)) = self.rt.block_on(repo.get_raw::<ipld_core::ipld::Ipld>(&key)) {

     

       
416
       
 
       
                reply.data(&serde_json::to_string_pretty(&val).unwrap().as_bytes()[offset as usize..]);

     

       
417
       
 
       
                return;

     

       
418
       
 
       
            }