Skip to content

Commit b14a173

Browse files
johan-bjareholtjohan-bjareholt
committed
aw-server: Replace all errors with HttpErrorJson
1 parent 3b126cc commit b14a173

File tree

7 files changed

+235
-119
lines changed

7 files changed

+235
-119
lines changed

‎aw-server/src/endpoints/bucket.rs‎

Lines changed: 97 additions & 49 deletions
Original file line numberDiff line numberDiff line change
@@ -12,36 +12,45 @@ use aw_models::Event;
1212

1313
use rocket::http::Header;
1414
use rocket::http::Status;
15-
use rocket::response::status;
1615
use rocket::response::Response;
1716
use rocket::State;
1817

19-
use crate::endpoints::{http_err, http_ok, HttpResponse, ServerState};
18+
use crate::endpoints::{HttpErrorJson, ServerState};
2019

2120
use aw_datastore::DatastoreError;
2221

2322
#[get("/")]
24-
pub fn buckets_get(state: State<ServerState>) -> Result<Json<HashMap<String, Bucket>>, Status> {
23+
pub fn buckets_get(
24+
state: State<ServerState>,
25+
) -> Result<Json<HashMap<String, Bucket>>, HttpErrorJson> {
2526
let datastore = endpoints_get_lock!(state.datastore);
2627
match datastore.get_buckets() {
2728
Ok(bucketlist) => Ok(Json(bucketlist)),
2829
Err(e) => {
29-
warn!("Unexpected error: {:?}", e);
30-
Err(Status::InternalServerError)
30+
let err_msg = format!("Unexpected error: {:?}", e);
31+
warn!("{}", err_msg);
32+
Err(HttpErrorJson::new(Status::InternalServerError, err_msg))
3133
}
3234
}
3335
}
3436

3537
#[get("/<bucket_id>")]
36-
pub fn bucket_get(bucket_id: String, state: State<ServerState>) -> Result<Json<Bucket>, Status> {
38+
pub fn bucket_get(
39+
bucket_id: String,
40+
state: State<ServerState>,
41+
) -> Result<Json<Bucket>, HttpErrorJson> {
3742
let datastore = endpoints_get_lock!(state.datastore);
3843
match datastore.get_bucket(&bucket_id) {
3944
Ok(bucket) => Ok(Json(bucket)),
4045
Err(e) => match e {
41-
DatastoreError::NoSuchBucket => Err(Status::NotFound),
46+
DatastoreError::NoSuchBucket => Err(HttpErrorJson::new(
47+
Status::NotFound,
48+
"The requested bucket does not exist".to_string(),
49+
)),
4250
_ => {
43-
warn!("Unexpected error: {:?}", e);
44-
Err(Status::InternalServerError)
51+
let err_msg = format!("Unexpected error: {:?}", e);
52+
warn!("{}", err_msg);
53+
Err(HttpErrorJson::new(Status::InternalServerError, err_msg))
4554
}
4655
},
4756
}
@@ -52,7 +61,7 @@ pub fn bucket_new(
5261
bucket_id: String,
5362
message: Json<Bucket>,
5463
state: State<ServerState>,
55-
) -> HttpResponse {
64+
) -> Result<(), HttpErrorJson> {
5665
let mut bucket = message.into_inner();
5766
if bucket.id != bucket_id {
5867
bucket.id = bucket_id;
@@ -63,22 +72,26 @@ pub fn bucket_new(
6372
Ok(ds) => ds,
6473
Err(e) => {
6574
warn!("Taking datastore lock failed, returning 504: {}", e);
66-
return http_err(
75+
return Err(HttpErrorJson::new(
6776
Status::ServiceUnavailable,
6877
"Takind datastore lock failed".to_string(),
69-
);
78+
));
7079
}
7180
};
7281
let ret = datastore.create_bucket(&bucket);
7382
match ret {
74-
Ok(_) => http_ok(json!(null)),
83+
Ok(_) => Ok(()),
7584
Err(err) => match err {
76-
DatastoreError::BucketAlreadyExists => {
77-
http_err(Status::NotModified, "Bucket already exists".to_string())
78-
}
85+
DatastoreError::BucketAlreadyExists => Err(HttpErrorJson::new(
86+
Status::NotModified,
87+
"Bucket already exists".to_string(),
88+
)),
7989
_ => {
8090
warn!("Unexpected error: {:?}", err);
81-
http_err(Status::InternalServerError, format!("{:?}", err))
91+
Err(HttpErrorJson::new(
92+
Status::InternalServerError,
93+
format!("{:?}", err),
94+
))
8295
}
8396
},
8497
}
@@ -91,16 +104,17 @@ pub fn bucket_events_get(
91104
end: Option<String>,
92105
limit: Option<u64>,
93106
state: State<ServerState>,
94-
) -> Result<Json<Vec<Event>>, Status> {
107+
) -> Result<Json<Vec<Event>>, HttpErrorJson> {
95108
let starttime: Option<DateTime<Utc>> = match start {
96109
Some(dt_str) => match DateTime::parse_from_rfc3339(&dt_str) {
97110
Ok(dt) => Some(dt.with_timezone(&Utc)),
98111
Err(e) => {
99-
warn!(
112+
let err_msg = format!(
100113
"Failed to parse starttime, datetime needs to be in rfc3339 format: {}",
101114
e
102115
);
103-
return Err(Status::BadRequest);
116+
warn!("{}", err_msg);
117+
return Err(HttpErrorJson::new(Status::BadRequest, err_msg));
104118
}
105119
},
106120
None => None,
@@ -109,11 +123,12 @@ pub fn bucket_events_get(
109123
Some(dt_str) => match DateTime::parse_from_rfc3339(&dt_str) {
110124
Ok(dt) => Some(dt.with_timezone(&Utc)),
111125
Err(e) => {
112-
warn!(
126+
let err_msg = format!(
113127
"Failed to parse endtime, datetime needs to be in rfc3339 format: {}",
114128
e
115129
);
116-
return Err(Status::BadRequest);
130+
warn!("{}", err_msg);
131+
return Err(HttpErrorJson::new(Status::BadRequest, err_msg));
117132
}
118133
},
119134
None => None,
@@ -123,10 +138,14 @@ pub fn bucket_events_get(
123138
match res {
124139
Ok(events) => Ok(Json(events)),
125140
Err(err) => match err {
126-
DatastoreError::NoSuchBucket => Err(Status::NotFound),
141+
DatastoreError::NoSuchBucket => Err(HttpErrorJson::new(
142+
Status::NotFound,
143+
"The requested bucket does not exist".to_string(),
144+
)),
127145
e => {
128-
warn!("Failed to fetch events: {:?}", e);
129-
Err(Status::InternalServerError)
146+
let err_msg = format!("Failed to fetch events: {:?}", e);
147+
warn!("{}", err_msg);
148+
Err(HttpErrorJson::new(Status::InternalServerError, err_msg))
130149
}
131150
},
132151
}
@@ -137,16 +156,20 @@ pub fn bucket_events_create(
137156
bucket_id: String,
138157
events: Json<Vec<Event>>,
139158
state: State<ServerState>,
140-
) -> Result<Json<Vec<Event>>, Status> {
159+
) -> Result<Json<Vec<Event>>, HttpErrorJson> {
141160
let datastore = endpoints_get_lock!(state.datastore);
142161
let res = datastore.insert_events(&bucket_id, &events);
143162
match res {
144163
Ok(events) => Ok(Json(events)),
145164
Err(e) => match e {
146-
DatastoreError::NoSuchBucket => Err(Status::NotFound),
165+
DatastoreError::NoSuchBucket => Err(HttpErrorJson::new(
166+
Status::NotFound,
167+
"The requested bucket does not exist".to_string(),
168+
)),
147169
e => {
148-
warn!("Failed to create event(s): {:?}", e);
149-
Err(Status::InternalServerError)
170+
let err_msg = format!("Failed to create event(s): {:?}", e);
171+
warn!("{}", err_msg);
172+
Err(HttpErrorJson::new(Status::InternalServerError, err_msg))
150173
}
151174
},
152175
}
@@ -162,16 +185,20 @@ pub fn bucket_events_heartbeat(
162185
heartbeat_json: Json<Event>,
163186
pulsetime: f64,
164187
state: State<ServerState>,
165-
) -> Result<Json<Event>, Status> {
188+
) -> Result<Json<Event>, HttpErrorJson> {
166189
let heartbeat = heartbeat_json.into_inner();
167190
let datastore = endpoints_get_lock!(state.datastore);
168191
match datastore.heartbeat(&bucket_id, heartbeat, pulsetime) {
169192
Ok(e) => Ok(Json(e)),
170193
Err(err) => match err {
171-
DatastoreError::NoSuchBucket => Err(Status::NotFound),
194+
DatastoreError::NoSuchBucket => Err(HttpErrorJson::new(
195+
Status::NotFound,
196+
"The requested bucket does not exist".to_string(),
197+
)),
172198
err => {
173-
warn!("Heartbeat failed: {:?}", err);
174-
Err(Status::InternalServerError)
199+
let err_msg = format!("Heartbeat failed: {:?}", err);
200+
warn!("{}", err_msg);
201+
Err(HttpErrorJson::new(Status::InternalServerError, err_msg))
175202
}
176203
},
177204
}
@@ -181,16 +208,20 @@ pub fn bucket_events_heartbeat(
181208
pub fn bucket_event_count(
182209
bucket_id: String,
183210
state: State<ServerState>,
184-
) -> Result<Json<u64>, Status> {
211+
) -> Result<Json<u64>, HttpErrorJson> {
185212
let datastore = endpoints_get_lock!(state.datastore);
186213
let res = datastore.get_event_count(&bucket_id, None, None);
187214
match res {
188215
Ok(eventcount) => Ok(Json(eventcount as u64)),
189216
Err(e) => match e {
190-
DatastoreError::NoSuchBucket => Err(Status::NotFound),
217+
DatastoreError::NoSuchBucket => Err(HttpErrorJson::new(
218+
Status::NotFound,
219+
"The requested bucket does not exist".to_string(),
220+
)),
191221
e => {
192-
warn!("Failed to count events: {:?}", e);
193-
Err(Status::InternalServerError)
222+
let err_msg = format!("Failed to count events: {:?}", e);
223+
warn!("{}", err_msg);
224+
Err(HttpErrorJson::new(Status::InternalServerError, err_msg))
194225
}
195226
},
196227
}
@@ -201,33 +232,46 @@ pub fn bucket_events_delete_by_id(
201232
bucket_id: String,
202233
event_id: i64,
203234
state: State<ServerState>,
204-
) -> Result<(), Status> {
235+
) -> Result<(), HttpErrorJson> {
205236
let datastore = endpoints_get_lock!(state.datastore);
206237
match datastore.delete_events_by_id(&bucket_id, vec![event_id]) {
207238
Ok(_) => Ok(()),
208239
Err(err) => match err {
209-
DatastoreError::NoSuchBucket => Err(Status::NotFound),
240+
DatastoreError::NoSuchBucket => Err(HttpErrorJson::new(
241+
Status::NotFound,
242+
"The requested bucket does not exist".to_string(),
243+
)),
210244
err => {
211-
warn!("Delete events by id failed: {:?}", err);
212-
Err(Status::InternalServerError)
245+
let err_msg = format!("Delete events by id failed: {:?}", err);
246+
warn!("{}", err_msg);
247+
Err(HttpErrorJson::new(Status::InternalServerError, err_msg))
213248
}
214249
},
215250
}
216251
}
217252

218253
#[get("/<bucket_id>/export")]
219-
pub fn bucket_export(bucket_id: String, state: State<ServerState>) -> Result<Response, Status> {
254+
pub fn bucket_export(
255+
bucket_id: String,
256+
state: State<ServerState>,
257+
) -> Result<Response, HttpErrorJson> {
220258
let datastore = endpoints_get_lock!(state.datastore);
221259
let mut export = BucketsExport {
222260
buckets: HashMap::new(),
223261
};
224262
let mut bucket = match datastore.get_bucket(&bucket_id) {
225263
Ok(bucket) => bucket,
226264
Err(err) => match err {
227-
DatastoreError::NoSuchBucket => return Err(Status::NotFound),
265+
DatastoreError::NoSuchBucket => {
266+
return Err(HttpErrorJson::new(
267+
Status::NotFound,
268+
"The requested bucket does not exist".to_string(),
269+
))
270+
}
228271
e => {
229-
warn!("Failed to fetch events: {:?}", e);
230-
return Err(Status::InternalServerError);
272+
let err_msg = format!("Failed to fetch events: {:?}", e);
273+
warn!("{}", err_msg);
274+
return Err(HttpErrorJson::new(Status::InternalServerError, err_msg));
231275
}
232276
},
233277
};
@@ -250,15 +294,19 @@ pub fn bucket_export(bucket_id: String, state: State<ServerState>) -> Result<Res
250294
}
251295

252296
#[delete("/<bucket_id>")]
253-
pub fn bucket_delete(bucket_id: String, state: State<ServerState>) -> Result<(), Status> {
297+
pub fn bucket_delete(bucket_id: String, state: State<ServerState>) -> Result<(), HttpErrorJson> {
254298
let datastore = endpoints_get_lock!(state.datastore);
255299
match datastore.delete_bucket(&bucket_id) {
256300
Ok(_) => Ok(()),
257301
Err(e) => match e {
258-
DatastoreError::NoSuchBucket => Err(Status::NotFound),
302+
DatastoreError::NoSuchBucket => Err(HttpErrorJson::new(
303+
Status::NotFound,
304+
"The requested bucket does not exist".to_string(),
305+
)),
259306
e => {
260-
warn!("Failed to delete bucket: {:?}", e);
261-
Err(Status::InternalServerError)
307+
let err_msg = format!("Failed to delete bucket: {:?}", e);
308+
warn!("{}", err_msg);
309+
Err(HttpErrorJson::new(Status::InternalServerError, err_msg))
262310
}
263311
},
264312
}

‎aw-server/src/endpoints/export.rs‎

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -8,17 +8,18 @@ use rocket::State;
88

99
use aw_models::BucketsExport;
1010

11-
use crate::endpoints::ServerState;
11+
use crate::endpoints::{HttpErrorJson, ServerState};
1212

1313
#[get("/")]
14-
pub fn buckets_export(state: State<ServerState>) -> Result<Response, Status> {
14+
pub fn buckets_export(state: State<ServerState>) -> Result<Response, HttpErrorJson> {
1515
let datastore = endpoints_get_lock!(state.datastore);
1616
let mut export = BucketsExport {
1717
buckets: HashMap::new(),
1818
};
1919
let mut buckets = datastore.get_buckets().unwrap();
2020
for (bid, mut bucket) in buckets.drain() {
2121
bucket.events = Some(
22+
// TODO: Remove expect
2223
datastore
2324
.get_events(&bid, None, None, None)
2425
.expect("Failed to get events for bucket"),

‎aw-server/src/endpoints/import.rs‎

Lines changed: 11 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -13,16 +13,17 @@ use aw_models::BucketsExport;
1313

1414
use aw_datastore::Datastore;
1515

16-
use crate::endpoints::ServerState;
16+
use crate::endpoints::{HttpErrorJson, ServerState};
1717

18-
fn import(datastore_mutex: &Mutex<Datastore>, import: BucketsExport) -> Result<(), Status> {
18+
fn import(datastore_mutex: &Mutex<Datastore>, import: BucketsExport) -> Result<(), HttpErrorJson> {
1919
let datastore = endpoints_get_lock!(datastore_mutex);
2020
for (_bucketname, bucket) in import.buckets {
2121
match datastore.create_bucket(&bucket) {
2222
Ok(_) => (),
2323
Err(e) => {
24-
warn!("Failed to import bucket: {:?}", e);
25-
return Err(Status::InternalServerError);
24+
let err_msg = format!("Failed to import bucket: {:?}", e);
25+
warn!("{}", err_msg);
26+
return Err(HttpErrorJson::new(Status::InternalServerError, err_msg));
2627
}
2728
}
2829
}
@@ -33,7 +34,7 @@ fn import(datastore_mutex: &Mutex<Datastore>, import: BucketsExport) -> Result<(
3334
pub fn bucket_import_json(
3435
state: State<ServerState>,
3536
json_data: Json<BucketsExport>,
36-
) -> Result<(), Status> {
37+
) -> Result<(), HttpErrorJson> {
3738
import(&state.datastore, json_data.into_inner())
3839
}
3940

@@ -44,13 +45,15 @@ pub fn bucket_import_form(
4445
state: State<ServerState>,
4546
cont_type: &ContentType,
4647
data: Data,
47-
) -> Result<(), Status> {
48+
) -> Result<(), HttpErrorJson> {
4849
let (_, boundary) = cont_type
4950
.params()
5051
.find(|&(k, _)| k == "boundary")
5152
.ok_or_else(|| {
52-
warn!("`Content-Type: multipart/form-data` boundary param not provided");
53-
Status::BadRequest
53+
return HttpErrorJson::new(
54+
Status::BadRequest,
55+
"`Content-Type: multipart/form-data` boundary param not provided".to_string(),
56+
);
5457
})?;
5558

5659
let string = process_multipart_packets(boundary, data);

0 commit comments

Comments
 (0)