Skip to content

Commit acd381c

Browse files
nick1udwignick1udwig
committed
fix vfs async (compiling at least -- functionality tbd)
1 parent 19978ba commit acd381c

File tree

2 files changed

+52
-52
lines changed

2 files changed

+52
-52
lines changed

src/vfs/directory_async.rs renamed to src/vfs/directory/directory_async.rs

File renamed without changes.

src/vfs/file_async.rs renamed to src/vfs/file/file_async.rs

Lines changed: 52 additions & 52 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
use super::{
2-
parse_response, vfs_request, FileMetadata, SeekFrom, VfsAction, VfsError, VfsResponse,
2+
vfs_request, FileMetadata, SeekFrom, VfsAction, VfsError, VfsResponse,
33
};
44
use crate::{get_blob, hyperapp, PackageId};
55

@@ -20,11 +20,11 @@ impl FileAsync {
2020
pub async fn read(&self) -> Result<Vec<u8>, VfsError> {
2121
let request = vfs_request(&self.path, VfsAction::Read).expects_response(self.timeout);
2222

23-
let resp_bytes = hyperapp::send_rmp::<Vec<u8>>(request)
23+
let response = hyperapp::send::<VfsResponse>(request)
2424
.await
25-
.map_err(|e| VfsError::SendError(crate::SendErrorKind::Timeout))?;
25+
.map_err(|_e| VfsError::SendError(crate::SendErrorKind::Timeout))?;
2626

27-
match parse_response(&resp_bytes)? {
27+
match response {
2828
VfsResponse::Read => {
2929
let data = match get_blob() {
3030
Some(bytes) => bytes.bytes,
@@ -48,11 +48,11 @@ impl FileAsync {
4848
pub async fn read_into(&self, buffer: &mut [u8]) -> Result<usize, VfsError> {
4949
let request = vfs_request(&self.path, VfsAction::Read).expects_response(self.timeout);
5050

51-
let resp_bytes = hyperapp::send_rmp::<Vec<u8>>(request)
51+
let response = hyperapp::send::<VfsResponse>(request)
5252
.await
53-
.map_err(|e| VfsError::SendError(crate::SendErrorKind::Timeout))?;
53+
.map_err(|_e| VfsError::SendError(crate::SendErrorKind::Timeout))?;
5454

55-
match parse_response(&resp_bytes)? {
55+
match response {
5656
VfsResponse::Read => {
5757
let data = get_blob().unwrap_or_default().bytes;
5858
let len = std::cmp::min(data.len(), buffer.len());
@@ -73,11 +73,11 @@ impl FileAsync {
7373
let request =
7474
vfs_request(&self.path, VfsAction::ReadExact { length }).expects_response(self.timeout);
7575

76-
let resp_bytes = hyperapp::send_rmp::<Vec<u8>>(request)
76+
let response = hyperapp::send::<VfsResponse>(request)
7777
.await
78-
.map_err(|e| VfsError::SendError(crate::SendErrorKind::Timeout))?;
78+
.map_err(|_e| VfsError::SendError(crate::SendErrorKind::Timeout))?;
7979

80-
match parse_response(&resp_bytes)? {
80+
match response {
8181
VfsResponse::Read => {
8282
let data = get_blob().unwrap_or_default().bytes;
8383
let len = std::cmp::min(data.len(), buffer.len());
@@ -95,11 +95,11 @@ impl FileAsync {
9595
pub async fn read_to_end(&self) -> Result<Vec<u8>, VfsError> {
9696
let request = vfs_request(&self.path, VfsAction::ReadToEnd).expects_response(self.timeout);
9797

98-
let resp_bytes = hyperapp::send_rmp::<Vec<u8>>(request)
98+
let response = hyperapp::send::<VfsResponse>(request)
9999
.await
100-
.map_err(|e| VfsError::SendError(crate::SendErrorKind::Timeout))?;
100+
.map_err(|_e| VfsError::SendError(crate::SendErrorKind::Timeout))?;
101101

102-
match parse_response(&resp_bytes)? {
102+
match response {
103103
VfsResponse::Read => Ok(get_blob().unwrap_or_default().bytes),
104104
VfsResponse::Err(e) => Err(e),
105105
_ => Err(VfsError::ParseError {
@@ -113,11 +113,11 @@ impl FileAsync {
113113
let request =
114114
vfs_request(&self.path, VfsAction::ReadToString).expects_response(self.timeout);
115115

116-
let resp_bytes = hyperapp::send_rmp::<Vec<u8>>(request)
116+
let response = hyperapp::send::<VfsResponse>(request)
117117
.await
118-
.map_err(|e| VfsError::SendError(crate::SendErrorKind::Timeout))?;
118+
.map_err(|_e| VfsError::SendError(crate::SendErrorKind::Timeout))?;
119119

120-
match parse_response(&resp_bytes)? {
120+
match response {
121121
VfsResponse::ReadToString(s) => Ok(s),
122122
VfsResponse::Err(e) => Err(e),
123123
_ => Err(VfsError::ParseError {
@@ -132,11 +132,11 @@ impl FileAsync {
132132
.blob_bytes(buffer)
133133
.expects_response(self.timeout);
134134

135-
let resp_bytes = hyperapp::send_rmp::<Vec<u8>>(request)
135+
let response = hyperapp::send::<VfsResponse>(request)
136136
.await
137-
.map_err(|e| VfsError::SendError(crate::SendErrorKind::Timeout))?;
137+
.map_err(|_e| VfsError::SendError(crate::SendErrorKind::Timeout))?;
138138

139-
match parse_response(&resp_bytes)? {
139+
match response {
140140
VfsResponse::Ok => Ok(()),
141141
VfsResponse::Err(e) => Err(e),
142142
_ => Err(VfsError::ParseError {
@@ -151,11 +151,11 @@ impl FileAsync {
151151
.blob_bytes(buffer)
152152
.expects_response(self.timeout);
153153

154-
let resp_bytes = hyperapp::send_rmp::<Vec<u8>>(request)
154+
let response = hyperapp::send::<VfsResponse>(request)
155155
.await
156-
.map_err(|e| VfsError::SendError(crate::SendErrorKind::Timeout))?;
156+
.map_err(|_e| VfsError::SendError(crate::SendErrorKind::Timeout))?;
157157

158-
match parse_response(&resp_bytes)? {
158+
match response {
159159
VfsResponse::Ok => Ok(()),
160160
VfsResponse::Err(e) => Err(e),
161161
_ => Err(VfsError::ParseError {
@@ -170,11 +170,11 @@ impl FileAsync {
170170
.blob_bytes(buffer)
171171
.expects_response(self.timeout);
172172

173-
let resp_bytes = hyperapp::send_rmp::<Vec<u8>>(request)
173+
let response = hyperapp::send::<VfsResponse>(request)
174174
.await
175-
.map_err(|e| VfsError::SendError(crate::SendErrorKind::Timeout))?;
175+
.map_err(|_e| VfsError::SendError(crate::SendErrorKind::Timeout))?;
176176

177-
match parse_response(&resp_bytes)? {
177+
match response {
178178
VfsResponse::Ok => Ok(()),
179179
VfsResponse::Err(e) => Err(e),
180180
_ => Err(VfsError::ParseError {
@@ -187,11 +187,11 @@ impl FileAsync {
187187
pub async fn seek(&mut self, pos: SeekFrom) -> Result<u64, VfsError> {
188188
let request = vfs_request(&self.path, VfsAction::Seek(pos)).expects_response(self.timeout);
189189

190-
let resp_bytes = hyperapp::send_rmp::<Vec<u8>>(request)
190+
let response = hyperapp::send::<VfsResponse>(request)
191191
.await
192-
.map_err(|e| VfsError::SendError(crate::SendErrorKind::Timeout))?;
192+
.map_err(|_e| VfsError::SendError(crate::SendErrorKind::Timeout))?;
193193

194-
match parse_response(&resp_bytes)? {
194+
match response {
195195
VfsResponse::SeekFrom {
196196
new_offset: new_pos,
197197
} => Ok(new_pos),
@@ -212,11 +212,11 @@ impl FileAsync {
212212
)
213213
.expects_response(self.timeout);
214214

215-
let resp_bytes = hyperapp::send_rmp::<Vec<u8>>(request)
215+
let response = hyperapp::send::<VfsResponse>(request)
216216
.await
217-
.map_err(|e| VfsError::SendError(crate::SendErrorKind::Timeout))?;
217+
.map_err(|_e| VfsError::SendError(crate::SendErrorKind::Timeout))?;
218218

219-
match parse_response(&resp_bytes)? {
219+
match response {
220220
VfsResponse::Ok => Ok(FileAsync {
221221
path: path.to_string(),
222222
timeout: self.timeout,
@@ -233,11 +233,11 @@ impl FileAsync {
233233
let request =
234234
vfs_request(&self.path, VfsAction::SetLen(size)).expects_response(self.timeout);
235235

236-
let resp_bytes = hyperapp::send_rmp::<Vec<u8>>(request)
236+
let response = hyperapp::send::<VfsResponse>(request)
237237
.await
238-
.map_err(|e| VfsError::SendError(crate::SendErrorKind::Timeout))?;
238+
.map_err(|_e| VfsError::SendError(crate::SendErrorKind::Timeout))?;
239239

240-
match parse_response(&resp_bytes)? {
240+
match response {
241241
VfsResponse::Ok => Ok(()),
242242
VfsResponse::Err(e) => Err(e),
243243
_ => Err(VfsError::ParseError {
@@ -250,11 +250,11 @@ impl FileAsync {
250250
pub async fn metadata(&self) -> Result<FileMetadata, VfsError> {
251251
let request = vfs_request(&self.path, VfsAction::Metadata).expects_response(self.timeout);
252252

253-
let resp_bytes = hyperapp::send_rmp::<Vec<u8>>(request)
253+
let response = hyperapp::send::<VfsResponse>(request)
254254
.await
255-
.map_err(|e| VfsError::SendError(crate::SendErrorKind::Timeout))?;
255+
.map_err(|_e| VfsError::SendError(crate::SendErrorKind::Timeout))?;
256256

257-
match parse_response(&resp_bytes)? {
257+
match response {
258258
VfsResponse::Metadata(metadata) => Ok(metadata),
259259
VfsResponse::Err(e) => Err(e),
260260
_ => Err(VfsError::ParseError {
@@ -267,11 +267,11 @@ impl FileAsync {
267267
pub async fn sync_all(&self) -> Result<(), VfsError> {
268268
let request = vfs_request(&self.path, VfsAction::SyncAll).expects_response(self.timeout);
269269

270-
let resp_bytes = hyperapp::send_rmp::<Vec<u8>>(request)
270+
let response = hyperapp::send::<VfsResponse>(request)
271271
.await
272-
.map_err(|e| VfsError::SendError(crate::SendErrorKind::Timeout))?;
272+
.map_err(|_e| VfsError::SendError(crate::SendErrorKind::Timeout))?;
273273

274-
match parse_response(&resp_bytes)? {
274+
match response {
275275
VfsResponse::Ok => Ok(()),
276276
VfsResponse::Err(e) => Err(e),
277277
_ => Err(VfsError::ParseError {
@@ -300,11 +300,11 @@ pub async fn create_drive_async(
300300

301301
let request = vfs_request(&path, VfsAction::CreateDrive).expects_response(timeout);
302302

303-
let resp_bytes = hyperapp::send_rmp::<Vec<u8>>(request)
303+
let response = hyperapp::send::<VfsResponse>(request)
304304
.await
305-
.map_err(|e| VfsError::SendError(crate::SendErrorKind::Timeout))?;
305+
.map_err(|_e| VfsError::SendError(crate::SendErrorKind::Timeout))?;
306306

307-
match parse_response(&resp_bytes)? {
307+
match response {
308308
VfsResponse::Ok => Ok(path),
309309
VfsResponse::Err(e) => Err(e),
310310
_ => Err(VfsError::ParseError {
@@ -323,11 +323,11 @@ pub async fn open_file_async(
323323

324324
let request = vfs_request(path, VfsAction::OpenFile { create }).expects_response(timeout);
325325

326-
let resp_bytes = hyperapp::send_rmp::<Vec<u8>>(request)
326+
let response = hyperapp::send::<VfsResponse>(request)
327327
.await
328-
.map_err(|e| VfsError::SendError(crate::SendErrorKind::Timeout))?;
328+
.map_err(|_e| VfsError::SendError(crate::SendErrorKind::Timeout))?;
329329

330-
match parse_response(&resp_bytes)? {
330+
match response {
331331
VfsResponse::Ok => Ok(FileAsync {
332332
path: path.to_string(),
333333
timeout,
@@ -345,11 +345,11 @@ pub async fn create_file_async(path: &str, timeout: Option<u64>) -> Result<FileA
345345

346346
let request = vfs_request(path, VfsAction::CreateFile).expects_response(timeout);
347347

348-
let resp_bytes = hyperapp::send_rmp::<Vec<u8>>(request)
348+
let response = hyperapp::send::<VfsResponse>(request)
349349
.await
350-
.map_err(|e| VfsError::SendError(crate::SendErrorKind::Timeout))?;
350+
.map_err(|_e| VfsError::SendError(crate::SendErrorKind::Timeout))?;
351351

352-
match parse_response(&resp_bytes)? {
352+
match response {
353353
VfsResponse::Ok => Ok(FileAsync {
354354
path: path.to_string(),
355355
timeout,
@@ -367,11 +367,11 @@ pub async fn remove_file_async(path: &str, timeout: Option<u64>) -> Result<(), V
367367

368368
let request = vfs_request(path, VfsAction::RemoveFile).expects_response(timeout);
369369

370-
let resp_bytes = hyperapp::send_rmp::<Vec<u8>>(request)
370+
let response = hyperapp::send::<VfsResponse>(request)
371371
.await
372-
.map_err(|e| VfsError::SendError(crate::SendErrorKind::Timeout))?;
372+
.map_err(|_e| VfsError::SendError(crate::SendErrorKind::Timeout))?;
373373

374-
match parse_response(&resp_bytes)? {
374+
match response {
375375
VfsResponse::Ok => Ok(()),
376376
VfsResponse::Err(e) => Err(e.into()),
377377
_ => Err(VfsError::ParseError {

0 commit comments

Comments
 (0)