0ad60fe · typeable/servant

git.iko.soy/typeable/servant

on master help sign in

Document http error codes

0ad60feAlexander Kjeldaas11 years ago

servant-server/src/Servant/Server/Internal/ServantErr.hs+210

compare with master

unifiedsplit

@@ -23,6 +23,13 @@ responseServantErr ServantErr{..} = responseLBS status errHeaders errBody

23 where

24 status = HTTP.mkStatus errHTTPCode (BS.pack errReasonPhrase)

26+-- | 'err300' Multiple Choices

27+--

28+-- Example:

29+--

30+-- > failingHandler :: ExceptT ServantErr IO ()

31+-- > failingHandler = throwErr $ err300 { errBody = "I can't choose." }

32+--

26err300 :: ServantErr

33err300 :: ServantErr

27err300 = ServantErr { errHTTPCode = 300

34err300 = ServantErr { errHTTPCode = 300

28 , errReasonPhrase = "Multiple Choices"

35 , errReasonPhrase = "Multiple Choices"

@@ -30,6 +37,13 @@ err300 = ServantErr { errHTTPCode = 300

30 , errHeaders = []

37 , errHeaders = []

31 }

38 }

40+-- | 'err301' Moved Permanently

41+--

42+-- Example:

43+--

44+-- > failingHandler :: ExceptT ServantErr IO ()

45+-- > failingHandler = throwErr err301

46+--

33err301 :: ServantErr

47err301 :: ServantErr

34err301 = ServantErr { errHTTPCode = 301

48err301 = ServantErr { errHTTPCode = 301

35 , errReasonPhrase = "Moved Permanently"

49 , errReasonPhrase = "Moved Permanently"

@@ -37,6 +51,13 @@ err301 = ServantErr { errHTTPCode = 301

37 , errHeaders = []

51 , errHeaders = []

38 }

52 }

54+-- | 'err302' Found

55+--

56+-- Example:

57+--

58+-- > failingHandler :: ExceptT ServantErr IO ()

59+-- > failingHandler = throwErr err302

60+--

40err302 :: ServantErr

61err302 :: ServantErr

41err302 = ServantErr { errHTTPCode = 302

62err302 = ServantErr { errHTTPCode = 302

42 , errReasonPhrase = "Found"

63 , errReasonPhrase = "Found"

@@ -44,6 +65,13 @@ err302 = ServantErr { errHTTPCode = 302

44 , errHeaders = []

65 , errHeaders = []

45 }

66 }

68+-- | 'err303' See Other

69+--

70+-- Example:

71+--

72+-- > failingHandler :: ExceptT ServantErr IO ()

73+-- > failingHandler = throwErr err303

74+--

47err303 :: ServantErr

75err303 :: ServantErr

48err303 = ServantErr { errHTTPCode = 303

76err303 = ServantErr { errHTTPCode = 303

49 , errReasonPhrase = "See Other"

77 , errReasonPhrase = "See Other"

@@ -51,6 +79,13 @@ err303 = ServantErr { errHTTPCode = 303

51 , errHeaders = []

79 , errHeaders = []

52 }

80 }

82+-- | 'err304' Not Modified

83+--

84+-- Example:

85+--

86+-- > failingHandler :: ExceptT ServantErr IO ()

87+-- > failingHandler = throwErr err304

88+--

54err304 :: ServantErr

89err304 :: ServantErr

55err304 = ServantErr { errHTTPCode = 304

90err304 = ServantErr { errHTTPCode = 304

56 , errReasonPhrase = "Not Modified"

91 , errReasonPhrase = "Not Modified"

@@ -58,6 +93,13 @@ err304 = ServantErr { errHTTPCode = 304

58 , errHeaders = []

93 , errHeaders = []

59 }

94 }

96+-- | 'err305' Use Proxy

97+--

98+-- Example:

99+--

100+-- > failingHandler :: ExceptT ServantErr IO ()

101+-- > failingHandler = throwErr err305

102+--

61err305 :: ServantErr

103err305 :: ServantErr

62err305 = ServantErr { errHTTPCode = 305

104err305 = ServantErr { errHTTPCode = 305

63 , errReasonPhrase = "Use Proxy"

105 , errReasonPhrase = "Use Proxy"

@@ -65,6 +107,13 @@ err305 = ServantErr { errHTTPCode = 305

65 , errHeaders = []

107 , errHeaders = []

66 }

108 }

109

110+-- | 'err307' Temporary Redirect

111+--

112+-- Example:

113+--

114+-- > failingHandler :: ExceptT ServantErr IO ()

115+-- > failingHandler = throwErr $ err307

116+--

68err307 :: ServantErr

117err307 :: ServantErr

69err307 = ServantErr { errHTTPCode = 307

118err307 = ServantErr { errHTTPCode = 307

70 , errReasonPhrase = "Temporary Redirect"

119 , errReasonPhrase = "Temporary Redirect"

@@ -72,6 +121,13 @@ err307 = ServantErr { errHTTPCode = 307

72 , errHeaders = []

121 , errHeaders = []

73 }

122 }

123

124+-- | 'err400' Bad Request

125+--

126+-- Example:

127+--

128+-- > failingHandler :: ExceptT ServantErr IO ()

129+-- > failingHandler = throwErr $ err400 { errBody = "Your request makes no sense to me." }

130+--

75err400 :: ServantErr

131err400 :: ServantErr

76err400 = ServantErr { errHTTPCode = 400

132err400 = ServantErr { errHTTPCode = 400

77 , errReasonPhrase = "Bad Request"

133 , errReasonPhrase = "Bad Request"

@@ -79,6 +135,13 @@ err400 = ServantErr { errHTTPCode = 400

79 , errHeaders = []

135 , errHeaders = []

80 }

136 }

137

138+-- | 'err401' Unauthorized

139+--

140+-- Example:

141+--

142+-- > failingHandler :: ExceptT ServantErr IO ()

143+-- > failingHandler = throwErr $ err401 { errBody = "Your credentials are invalid." }

144+--

82err401 :: ServantErr

145err401 :: ServantErr

83err401 = ServantErr { errHTTPCode = 401

146err401 = ServantErr { errHTTPCode = 401

84 , errReasonPhrase = "Unauthorized"

147 , errReasonPhrase = "Unauthorized"

@@ -86,6 +149,13 @@ err401 = ServantErr { errHTTPCode = 401

86 , errHeaders = []

149 , errHeaders = []

87 }

150 }

151

152+-- | 'err402' Payment Required

153+--

154+-- Example:

155+--

156+-- > failingHandler :: ExceptT ServantErr IO ()

157+-- > failingHandler = throwErr $ err402 { errBody = "You have 0 credits. Please give me $$$." }

158+--

89err402 :: ServantErr

159err402 :: ServantErr

90err402 = ServantErr { errHTTPCode = 402

160err402 = ServantErr { errHTTPCode = 402

91 , errReasonPhrase = "Payment Required"

161 , errReasonPhrase = "Payment Required"

@@ -93,6 +163,13 @@ err402 = ServantErr { errHTTPCode = 402

93 , errHeaders = []

163 , errHeaders = []

94 }

164 }

165

166+-- | 'err403' Forbidden

167+--

168+-- Example:

169+--

170+-- > failingHandler :: ExceptT ServantErr IO ()

171+-- > failingHandler = throwErr $ err403 { errBody = "Please login first." }

172+--

96err403 :: ServantErr

173err403 :: ServantErr

97err403 = ServantErr { errHTTPCode = 403

174err403 = ServantErr { errHTTPCode = 403

98 , errReasonPhrase = "Forbidden"

175 , errReasonPhrase = "Forbidden"

@@ -100,6 +177,13 @@ err403 = ServantErr { errHTTPCode = 403

100 , errHeaders = []

177 , errHeaders = []

101 }

178 }

102

179

180+-- | 'err404' Not Found

181+--

182+-- Example:

183+--

184+-- > failingHandler :: ExceptT ServantErr IO ()

185+-- > failingHandler = throwErr $ err404 { errBody = "(╯°□°）╯︵ ┻━┻)." }

186+--

103err404 :: ServantErr

187err404 :: ServantErr

104err404 = ServantErr { errHTTPCode = 404

188err404 = ServantErr { errHTTPCode = 404

105 , errReasonPhrase = "Not Found"

189 , errReasonPhrase = "Not Found"

@@ -107,6 +191,13 @@ err404 = ServantErr { errHTTPCode = 404

107 , errHeaders = []

191 , errHeaders = []

108 }

192 }

109

193

194+-- | 'err405' Method Not Allowed

195+--

196+-- Example:

197+--

198+-- > failingHandler :: ExceptT ServantErr IO ()

199+-- > failingHandler = throwErr $ err405 { errBody = "Your account privileges does not allow for this. Please pay $$$." }

200+--

110err405 :: ServantErr

201err405 :: ServantErr

111err405 = ServantErr { errHTTPCode = 405

202err405 = ServantErr { errHTTPCode = 405

112 , errReasonPhrase = "Method Not Allowed"

203 , errReasonPhrase = "Method Not Allowed"

@@ -114,6 +205,13 @@ err405 = ServantErr { errHTTPCode = 405

114 , errHeaders = []

205 , errHeaders = []

115 }

206 }

116

207

208+-- | 'err406' Not Acceptable

209+--

210+-- Example:

211+--

212+-- > failingHandler :: ExceptT ServantErr IO ()

213+-- > failingHandler = throwErr $ err406

214+--

117err406 :: ServantErr

215err406 :: ServantErr

118err406 = ServantErr { errHTTPCode = 406

216err406 = ServantErr { errHTTPCode = 406

119 , errReasonPhrase = "Not Acceptable"

217 , errReasonPhrase = "Not Acceptable"

@@ -121,6 +219,13 @@ err406 = ServantErr { errHTTPCode = 406

121 , errHeaders = []

219 , errHeaders = []

122 }

220 }

123

221

222+-- | 'err407' Proxy Authentication Required

223+--

224+-- Example:

225+--

226+-- > failingHandler :: ExceptT ServantErr IO ()

227+-- > failingHandler = throwErr $ err407

228+--

124err407 :: ServantErr

229err407 :: ServantErr

125err407 = ServantErr { errHTTPCode = 407

230err407 = ServantErr { errHTTPCode = 407

126 , errReasonPhrase = "Proxy Authentication Required"

231 , errReasonPhrase = "Proxy Authentication Required"

@@ -128,6 +233,13 @@ err407 = ServantErr { errHTTPCode = 407

128 , errHeaders = []

233 , errHeaders = []

129 }

234 }

130

235

236+-- | 'err409' Conflict

237+--

238+-- Example:

239+--

240+-- > failingHandler :: ExceptT ServantErr IO ()

241+-- > failingHandler = throwErr $ err409 { errBody = "Transaction conflicts with 59879cb56c7c159231eeacdd503d755f7e835f74" }

242+--

131err409 :: ServantErr

243err409 :: ServantErr

132err409 = ServantErr { errHTTPCode = 409

244err409 = ServantErr { errHTTPCode = 409

133 , errReasonPhrase = "Conflict"

245 , errReasonPhrase = "Conflict"

@@ -135,6 +247,13 @@ err409 = ServantErr { errHTTPCode = 409

135 , errHeaders = []

247 , errHeaders = []

136 }

248 }

137

249

250+-- | 'err410' Gone

251+--

252+-- Example:

253+--

254+-- > failingHandler :: ExceptT ServantErr IO ()

255+-- > failingHandler = throwErr $ err410 { errBody = "I know it was here at some point, but.. I blame bad luck." }

256+--

138err410 :: ServantErr

257err410 :: ServantErr

139err410 = ServantErr { errHTTPCode = 410

258err410 = ServantErr { errHTTPCode = 410

140 , errReasonPhrase = "Gone"

259 , errReasonPhrase = "Gone"

@@ -142,6 +261,13 @@ err410 = ServantErr { errHTTPCode = 410

142 , errHeaders = []

261 , errHeaders = []

143 }

262 }

144

263

264+-- | 'err411' Length Required

265+--

266+-- Example:

267+--

268+-- > failingHandler :: ExceptT ServantErr IO ()

269+-- > failingHandler = throwErr $ err411

270+--

145err411 :: ServantErr

271err411 :: ServantErr

146err411 = ServantErr { errHTTPCode = 411

272err411 = ServantErr { errHTTPCode = 411

147 , errReasonPhrase = "Length Required"

273 , errReasonPhrase = "Length Required"

@@ -149,6 +275,13 @@ err411 = ServantErr { errHTTPCode = 411

149 , errHeaders = []

275 , errHeaders = []

150 }

276 }

151

277

278+-- | 'err412' Precondition Failed

279+--

280+-- Example:

281+--

282+-- > failingHandler :: ExceptT ServantErr IO ()

283+-- > failingHandler = throwErr $ err412 { errBody = "Precondition fail: x < 42 && y > 57" }

284+--

152err412 :: ServantErr

285err412 :: ServantErr

153err412 = ServantErr { errHTTPCode = 412

286err412 = ServantErr { errHTTPCode = 412

154 , errReasonPhrase = "Precondition Failed"

287 , errReasonPhrase = "Precondition Failed"

@@ -156,6 +289,13 @@ err412 = ServantErr { errHTTPCode = 412

156 , errHeaders = []

289 , errHeaders = []

157 }

290 }

158

291

292+-- | 'err413' Request Entity Too Large

293+--

294+-- Example:

295+--

296+-- > failingHandler :: ExceptT ServantErr IO ()

297+-- > failingHandler = throwErr $ err413 { errBody = "Request exceeded 64k." }

298+--

159err413 :: ServantErr

299err413 :: ServantErr

160err413 = ServantErr { errHTTPCode = 413

300err413 = ServantErr { errHTTPCode = 413

161 , errReasonPhrase = "Request Entity Too Large"

301 , errReasonPhrase = "Request Entity Too Large"

@@ -163,6 +303,13 @@ err413 = ServantErr { errHTTPCode = 413

163 , errHeaders = []

303 , errHeaders = []

164 }

304 }

165

305

306+-- | 'err414' Request-URI Too Large

307+--

308+-- Example:

309+--

310+-- > failingHandler :: ExceptT ServantErr IO ()

311+-- > failingHandler = throwErr $ err414 { errBody = "Maxiumu length is 64." }

312+--

166err414 :: ServantErr

313err414 :: ServantErr

167err414 = ServantErr { errHTTPCode = 414

314err414 = ServantErr { errHTTPCode = 414

168 , errReasonPhrase = "Request-URI Too Large"

315 , errReasonPhrase = "Request-URI Too Large"

@@ -170,6 +317,13 @@ err414 = ServantErr { errHTTPCode = 414

170 , errHeaders = []

317 , errHeaders = []

171 }

318 }

172

319

320+-- | 'err415' Unsupported Media Type

321+--

322+-- Example:

323+--

324+-- > failingHandler :: ExceptT ServantErr IO ()

325+-- > failingHandler = throwErr $ err415 { errBody = "Supported media types: gif, png" }

326+--

173err415 :: ServantErr

327err415 :: ServantErr

174err415 = ServantErr { errHTTPCode = 415

328err415 = ServantErr { errHTTPCode = 415

175 , errReasonPhrase = "Unsupported Media Type"

329 , errReasonPhrase = "Unsupported Media Type"

@@ -177,6 +331,13 @@ err415 = ServantErr { errHTTPCode = 415

177 , errHeaders = []

331 , errHeaders = []

178 }

332 }

179

333

334+-- | 'err416' Request range not satisfiable

335+--

336+-- Example:

337+--

338+-- > failingHandler :: ExceptT ServantErr IO ()

339+-- > failingHandler = throwErr $ err416 { errBody = "Valid range is [0, 424242]." }

340+--

180err416 :: ServantErr

341err416 :: ServantErr

181err416 = ServantErr { errHTTPCode = 416

342err416 = ServantErr { errHTTPCode = 416

182 , errReasonPhrase = "Request range not satisfiable"

343 , errReasonPhrase = "Request range not satisfiable"

@@ -184,6 +345,13 @@ err416 = ServantErr { errHTTPCode = 416

184 , errHeaders = []

345 , errHeaders = []

185 }

346 }

186

347

348+-- | 'err417' Expectation Failed

349+--

350+-- Example:

351+--

352+-- > failingHandler :: ExceptT ServantErr IO ()

353+-- > failingHandler = throwErr $ err417 { errBody = "I found a quux in the request. This isn't going to work." }

354+--

187err417 :: ServantErr

355err417 :: ServantErr

188err417 = ServantErr { errHTTPCode = 417

356err417 = ServantErr { errHTTPCode = 417

189 , errReasonPhrase = "Expectation Failed"

357 , errReasonPhrase = "Expectation Failed"

@@ -191,6 +359,13 @@ err417 = ServantErr { errHTTPCode = 417

191 , errHeaders = []

359 , errHeaders = []

192 }

360 }

193

361

362+-- | 'err500' Internal Server Error

363+--

364+-- Example:

365+--

366+-- > failingHandler :: ExceptT ServantErr IO ()

367+-- > failingHandler = throwErr $ err300 { errBody = "Exception in module A.B.C:55. Have a great day!" }

368+--

194err500 :: ServantErr

369err500 :: ServantErr

195err500 = ServantErr { errHTTPCode = 500

370err500 = ServantErr { errHTTPCode = 500

196 , errReasonPhrase = "Internal Server Error"

371 , errReasonPhrase = "Internal Server Error"

@@ -198,6 +373,13 @@ err500 = ServantErr { errHTTPCode = 500

198 , errHeaders = []

373 , errHeaders = []

199 }

374 }

200

375

376+-- | 'err501' Not Implemented

377+--

378+-- Example:

379+--

380+-- > failingHandler :: ExceptT ServantErr IO ()

381+-- > failingHandler = throwErr $ err501 { errBody = "/v1/foo is not supported with quux in the request." }

382+--

201err501 :: ServantErr

383err501 :: ServantErr

202err501 = ServantErr { errHTTPCode = 501

384err501 = ServantErr { errHTTPCode = 501

203 , errReasonPhrase = "Not Implemented"

385 , errReasonPhrase = "Not Implemented"

@@ -205,6 +387,13 @@ err501 = ServantErr { errHTTPCode = 501

205 , errHeaders = []

387 , errHeaders = []

206 }

388 }

207

389

390+-- | 'err502' Bad Gateway

391+--

392+-- Example:

393+--

394+-- > failingHandler :: ExceptT ServantErr IO ()

395+-- > failingHandler = throwErr $ err502 { errBody = "Tried gateway foo, bar, and baz. None responded." }

396+--

208err502 :: ServantErr

397err502 :: ServantErr

209err502 = ServantErr { errHTTPCode = 502

398err502 = ServantErr { errHTTPCode = 502

210 , errReasonPhrase = "Bad Gateway"

399 , errReasonPhrase = "Bad Gateway"

@@ -212,6 +401,13 @@ err502 = ServantErr { errHTTPCode = 502

212 , errHeaders = []

401 , errHeaders = []

213 }

402 }

214

403

404+-- | 'err503' Service Unavailable

405+--

406+-- Example:

407+--

408+-- > failingHandler :: ExceptT ServantErr IO ()

409+-- > failingHandler = throwErr $ err503 { errBody = "We're rewriting in PHP." }

410+--

215err503 :: ServantErr

411err503 :: ServantErr

216err503 = ServantErr { errHTTPCode = 503

412err503 = ServantErr { errHTTPCode = 503

217 , errReasonPhrase = "Service Unavailable"

413 , errReasonPhrase = "Service Unavailable"

@@ -219,6 +415,13 @@ err503 = ServantErr { errHTTPCode = 503

219 , errHeaders = []

415 , errHeaders = []

220 }

416 }

221

417

418+-- | 'err504' Gateway Time-out

419+--

420+-- Example:

421+--

422+-- > failingHandler :: ExceptT ServantErr IO ()

423+-- > failingHandler = throwErr $ err504 { errBody = "Backend foobar did not respond in 5 seconds." }

424+--

222err504 :: ServantErr

425err504 :: ServantErr

223err504 = ServantErr { errHTTPCode = 504

426err504 = ServantErr { errHTTPCode = 504

224 , errReasonPhrase = "Gateway Time-out"

427 , errReasonPhrase = "Gateway Time-out"

@@ -226,6 +429,13 @@ err504 = ServantErr { errHTTPCode = 504

226 , errHeaders = []

429 , errHeaders = []

227 }

430 }

228

431

432+-- | 'err505' HTTP Version not supported

433+--

434+-- Example usage:

435+--

436+-- > failingHandler :: ExceptT ServantErr IO ()

437+-- > failingHandler = throwErr $ err505 { errBody = "I support HTTP/4.0 only." }

438+--

229err505 :: ServantErr

439err505 :: ServantErr

230err505 = ServantErr { errHTTPCode = 505

440err505 = ServantErr { errHTTPCode = 505

231 , errReasonPhrase = "HTTP Version not supported"

441 , errReasonPhrase = "HTTP Version not supported"