commit c8ddedbb3f435f259ea0234126e06dcf4d26c352 · anil.recoil.org/slop

+3 -3

stack/requests/bin/dune

···

       1
       1
       -
       (executable

     

       2
       2
       -
        (public_name ocurl)

     

       3
       3
       -
        (name ocurl)

     

       1
       1
       +
       (executables

     

       2
       2
       +
        (public_names ocurl)

     

       3
       3
       +
        (names ocurl)

     

       4
       4
        
        (libraries requests eio_main cmdliner logs logs.fmt fmt.tty yojson))

+3 -27

stack/requests/bin/ocurl.ml

···

       212
       212
        
             | None, None -> None, headers

     

       213
       213
        
           in

     

       214
       214
        
       

     

       215
       215
       -
           (* Convert method to Requests.Method.t *)

     

       216
       216
       -
           let req_method = match method_ with

     

       217
       217
       -
             | `GET -> Requests.Method.GET

     

       218
       218
       -
             | `POST -> Requests.Method.POST

     

       219
       219
       -
             | `PUT -> Requests.Method.PUT

     

       220
       220
       -
             | `DELETE -> Requests.Method.DELETE

     

       221
       221
       -
             | `HEAD -> Requests.Method.HEAD

     

       222
       222
       -
             | `OPTIONS -> Requests.Method.OPTIONS

     

       223
       223
       -
             | `PATCH -> Requests.Method.PATCH

     

       224
       224
       -
           in

     

       215
       215
       +
           (* Convert to full Method.t type *)

     

       216
       216
       +
           let req_method : Requests.Method.t = (method_ :> Requests.Method.t) in

     

       225
       217
        
       

     

       226
       218
        
           (* Convert timeout float to Timeout.t *)

     

       227
       219
        
           let timeout_obj = Option.map (fun t -> Requests.Timeout.create ~total:t ()) timeout in

     
···

       264
       256
        
               Logs.app (fun m -> m "✓ Success")

     

       265
       257
        
       

     

       266
       258
        
           with

     

       267
       267
       -
           | Requests.TimeoutError ->

     

       268
       268
       -
               if not quiet then

     

       269
       269
       -
                 Logs.err (fun m -> m "Request timed out");

     

       270
       270
       -
               exit 1

     

       271
       271
       -
           | Requests.TooManyRedirects { url; count } ->

     

       272
       272
       -
               if not quiet then

     

       273
       273
       -
                 Logs.err (fun m -> m "Too many redirects (%d) following %s" count url);

     

       274
       274
       -
               exit 1

     

       275
       275
       -
           | Requests.ConnectionError msg ->

     

       276
       276
       -
               if not quiet then

     

       277
       277
       -
                 Logs.err (fun m -> m "Connection error: %s" msg);

     

       278
       278
       -
               exit 1

     

       279
       279
       -
           | Requests.HTTPError { status; body; _ } ->

     

       280
       280
       -
               if not quiet then

     

       281
       281
       -
                 Logs.err (fun m -> m "HTTP error %d: %s" status body);

     

       282
       282
       -
               exit 1

     

       283
       259
        
           | exn ->

     

       284
       260
        
               if not quiet then

     

       285
       285
       -
                 Logs.err (fun m -> m "Unexpected error: %s" (Printexc.to_string exn));

     

       261
       261
       +
                 Logs.err (fun m -> m "%a" Requests.Error.pp_exn exn);

     

       286
       262
        
               exit 1

     

       287
       263
        
         ) urls

     

       288
       264

-1

stack/requests/lib/body.ml

···

       83
       83
        
             (* Complex to calculate, handled during sending *)

     

       84
       84
        
             None

     

       85
       85
        
       

     

       86
       86
       -
       (* Convert Body.t to Cohttp body - internal use only *)

     

       87
       86
        
       let to_cohttp_body = function

     

       88
       87
        
         | Empty -> None

     

       89
       88
        
         | String { content; _ } -> Some (Cohttp_eio.Body.of_string content)

+2 -1

stack/requests/lib/body.mli

···

       46
       46
        
       val content_length : t -> int64 option

     

       47
       47
        
       (** Get content length if known *)

     

       48
       48
        
       

     

       49
       49
       -
       (** Internal use - not part of public API *)

     

       49
       49
       +
       (** Internal conversion for cohttp-eio integration *)

     

       50
       50
        
       val to_cohttp_body : t -> Cohttp_eio.Body.t option

     

       51
       51
       +
       (** Convert body to cohttp-eio body format *)

+171

stack/requests/lib/error.ml

···

       1
       1
       +
       (** Centralized error handling for the Requests library *)

     

       2
       2
       +
       

     

       3
       3
       +
       (** {1 Exception Types} *)

     

       4
       4
       +
       

     

       5
       5
       +
       exception Timeout

     

       6
       6
       +
       exception TooManyRedirects of { url: string; count: int; max: int }

     

       7
       7
       +
       exception ConnectionError of string

     

       8
       8
       +
       exception HTTPError of {

     

       9
       9
       +
         url: string;

     

       10
       10
       +
         status: int;

     

       11
       11
       +
         reason: string;

     

       12
       12
       +
         body: string option;

     

       13
       13
       +
         headers: Headers.t

     

       14
       14
       +
       }

     

       15
       15
       +
       exception AuthenticationError of string

     

       16
       16
       +
       exception SSLError of string

     

       17
       17
       +
       exception ProxyError of string

     

       18
       18
       +
       exception EncodingError of string

     

       19
       19
       +
       exception InvalidURL of string

     

       20
       20
       +
       exception InvalidRequest of string

     

       21
       21
       +
       

     

       22
       22
       +
       (** {1 Error Type} *)

     

       23
       23
       +
       

     

       24
       24
       +
       type t = [

     

       25
       25
       +
         | `Timeout

     

       26
       26
       +
         | `TooManyRedirects of string * int * int  (* url, count, max *)

     

       27
       27
       +
         | `ConnectionError of string

     

       28
       28
       +
         | `HTTPError of string * int * string * string option * Headers.t  (* url, status, reason, body, headers *)

     

       29
       29
       +
         | `AuthenticationError of string

     

       30
       30
       +
         | `SSLError of string

     

       31
       31
       +
         | `ProxyError of string

     

       32
       32
       +
         | `EncodingError of string

     

       33
       33
       +
         | `InvalidURL of string

     

       34
       34
       +
         | `InvalidRequest of string

     

       35
       35
       +
         | `UnknownError of string

     

       36
       36
       +
       ]

     

       37
       37
       +
       

     

       38
       38
       +
       (** {1 Conversion Functions} *)

     

       39
       39
       +
       

     

       40
       40
       +
       let of_exn = function

     

       41
       41
       +
         | Timeout -> Some `Timeout

     

       42
       42
       +
         | TooManyRedirects { url; count; max } ->

     

       43
       43
       +
             Some (`TooManyRedirects (url, count, max))

     

       44
       44
       +
         | ConnectionError msg -> Some (`ConnectionError msg)

     

       45
       45
       +
         | HTTPError { url; status; reason; body; headers } ->

     

       46
       46
       +
             Some (`HTTPError (url, status, reason, body, headers))

     

       47
       47
       +
         | AuthenticationError msg -> Some (`AuthenticationError msg)

     

       48
       48
       +
         | SSLError msg -> Some (`SSLError msg)

     

       49
       49
       +
         | ProxyError msg -> Some (`ProxyError msg)

     

       50
       50
       +
         | EncodingError msg -> Some (`EncodingError msg)

     

       51
       51
       +
         | InvalidURL msg -> Some (`InvalidURL msg)

     

       52
       52
       +
         | InvalidRequest msg -> Some (`InvalidRequest msg)

     

       53
       53
       +
         | _ -> None

     

       54
       54
       +
       

     

       55
       55
       +
       let to_exn = function

     

       56
       56
       +
         | `Timeout -> Timeout

     

       57
       57
       +
         | `TooManyRedirects (url, count, max) ->

     

       58
       58
       +
             TooManyRedirects { url; count; max }

     

       59
       59
       +
         | `ConnectionError msg -> ConnectionError msg

     

       60
       60
       +
         | `HTTPError (url, status, reason, body, headers) ->

     

       61
       61
       +
             HTTPError { url; status; reason; body; headers }

     

       62
       62
       +
         | `AuthenticationError msg -> AuthenticationError msg

     

       63
       63
       +
         | `SSLError msg -> SSLError msg

     

       64
       64
       +
         | `ProxyError msg -> ProxyError msg

     

       65
       65
       +
         | `EncodingError msg -> EncodingError msg

     

       66
       66
       +
         | `InvalidURL msg -> InvalidURL msg

     

       67
       67
       +
         | `InvalidRequest msg -> InvalidRequest msg

     

       68
       68
       +
         | `UnknownError msg -> Failure msg

     

       69
       69
       +
       

     

       70
       70
       +
       let raise error = Stdlib.raise (to_exn error)

     

       71
       71
       +
       

     

       72
       72
       +
       (** {1 Combinators} *)

     

       73
       73
       +
       

     

       74
       74
       +
       let catch f =

     

       75
       75
       +
         try Ok (f ())

     

       76
       76
       +
         with

     

       77
       77
       +
         | exn ->

     

       78
       78
       +
             match of_exn exn with

     

       79
       79
       +
             | Some err -> Error err

     

       80
       80
       +
             | None -> Error (`UnknownError (Printexc.to_string exn))

     

       81
       81
       +
       

     

       82
       82
       +
       let catch_async f = catch f  (* In Eio, regular catch works for async too *)

     

       83
       83
       +
       

     

       84
       84
       +
       let map f = function

     

       85
       85
       +
         | Ok x -> Ok (f x)

     

       86
       86
       +
         | Error e -> Error e

     

       87
       87
       +
       

     

       88
       88
       +
       let bind f = function

     

       89
       89
       +
         | Ok x -> f x

     

       90
       90
       +
         | Error e -> Error e

     

       91
       91
       +
       

     

       92
       92
       +
       let both a b =

     

       93
       93
       +
         match a, b with

     

       94
       94
       +
         | Ok x, Ok y -> Ok (x, y)

     

       95
       95
       +
         | Error e, _ -> Error e

     

       96
       96
       +
         | _, Error e -> Error e

     

       97
       97
       +
       

     

       98
       98
       +
       let get_exn = function

     

       99
       99
       +
         | Ok x -> x

     

       100
       100
       +
         | Error e -> raise e

     

       101
       101
       +
       

     

       102
       102
       +
       let get_or ~default = function

     

       103
       103
       +
         | Ok x -> x

     

       104
       104
       +
         | Error _ -> default

     

       105
       105
       +
       

     

       106
       106
       +
       let is_retryable = function

     

       107
       107
       +
         | `Timeout -> true

     

       108
       108
       +
         | `ConnectionError _ -> true

     

       109
       109
       +
         | `HTTPError (_, status, _, _, _) -> Status.is_retryable (Status.of_int status)

     

       110
       110
       +
         | `SSLError _ -> true

     

       111
       111
       +
         | `ProxyError _ -> true

     

       112
       112
       +
         | _ -> false

     

       113
       113
       +
       

     

       114
       114
       +
       let is_client_error = function

     

       115
       115
       +
         | `HTTPError (_, status, _, _, _) -> Status.is_client_error (Status.of_int status)

     

       116
       116
       +
         | `AuthenticationError _

     

       117
       117
       +
         | `InvalidURL _

     

       118
       118
       +
         | `InvalidRequest _ -> true

     

       119
       119
       +
         | _ -> false

     

       120
       120
       +
       

     

       121
       121
       +
       let is_server_error = function

     

       122
       122
       +
         | `HTTPError (_, status, _, _, _) -> Status.is_server_error (Status.of_int status)

     

       123
       123
       +
         | _ -> false

     

       124
       124
       +
       

     

       125
       125
       +
       

     

       126
       126
       +
       (** {1 Pretty Printing} *)

     

       127
       127
       +
       

     

       128
       128
       +
       let pp ppf = function

     

       129
       129
       +
         | `Timeout ->

     

       130
       130
       +
             Format.fprintf ppf "@[<2>Request Timeout:@ The request timed out@]"

     

       131
       131
       +
         | `TooManyRedirects (url, count, max) ->

     

       132
       132
       +
             Format.fprintf ppf "@[<2>Too Many Redirects:@ Exceeded maximum redirects (%d/%d) for URL: %s@]"

     

       133
       133
       +
               count max url

     

       134
       134
       +
         | `ConnectionError msg ->

     

       135
       135
       +
             Format.fprintf ppf "@[<2>Connection Error:@ %s@]" msg

     

       136
       136
       +
         | `HTTPError (url, status, reason, body, _headers) ->

     

       137
       137
       +
             Format.fprintf ppf "@[<v>@[<2>HTTP Error %d (%s):@ URL: %s@]" status reason url;

     

       138
       138
       +
             Option.iter (fun b ->

     

       139
       139
       +
               Format.fprintf ppf "@,@[<2>Response Body:@ %s@]" b

     

       140
       140
       +
             ) body;

     

       141
       141
       +
             Format.fprintf ppf "@]"

     

       142
       142
       +
         | `AuthenticationError msg ->

     

       143
       143
       +
             Format.fprintf ppf "@[<2>Authentication Error:@ %s@]" msg

     

       144
       144
       +
         | `SSLError msg ->

     

       145
       145
       +
             Format.fprintf ppf "@[<2>SSL/TLS Error:@ %s@]" msg

     

       146
       146
       +
         | `ProxyError msg ->

     

       147
       147
       +
             Format.fprintf ppf "@[<2>Proxy Error:@ %s@]" msg

     

       148
       148
       +
         | `EncodingError msg ->

     

       149
       149
       +
             Format.fprintf ppf "@[<2>Encoding Error:@ %s@]" msg

     

       150
       150
       +
         | `InvalidURL msg ->

     

       151
       151
       +
             Format.fprintf ppf "@[<2>Invalid URL:@ %s@]" msg

     

       152
       152
       +
         | `InvalidRequest msg ->

     

       153
       153
       +
             Format.fprintf ppf "@[<2>Invalid Request:@ %s@]" msg

     

       154
       154
       +
         | `UnknownError msg ->

     

       155
       155
       +
             Format.fprintf ppf "@[<2>Unknown Error:@ %s@]" msg

     

       156
       156
       +
       

     

       157
       157
       +
       let pp_exn ppf exn =

     

       158
       158
       +
         match of_exn exn with

     

       159
       159
       +
         | Some err -> pp ppf err

     

       160
       160
       +
         | None -> Format.fprintf ppf "%s" (Printexc.to_string exn)

     

       161
       161
       +
       

     

       162
       162
       +
       let to_string error =

     

       163
       163
       +
         Format.asprintf "%a" pp error

     

       164
       164
       +
       

     

       165
       165
       +
       (** {1 Syntax Module} *)

     

       166
       166
       +
       

     

       167
       167
       +
       module Syntax = struct

     

       168
       168
       +
         let ( let* ) x f = bind f x

     

       169
       169
       +
         let ( let+ ) x f = map f x

     

       170
       170
       +
         let ( and* ) = both

     

       171
       171
       +
       end

+124

stack/requests/lib/error.mli

···

       1
       1
       +
       (** Centralized error handling for the Requests library *)

     

       2
       2
       +
       

     

       3
       3
       +
       (** {1 Exception Types} *)

     

       4
       4
       +
       

     

       5
       5
       +
       (** Raised when a request times out *)

     

       6
       6
       +
       exception Timeout

     

       7
       7
       +
       

     

       8
       8
       +
       (** Raised when too many redirects are encountered *)

     

       9
       9
       +
       exception TooManyRedirects of { url: string; count: int; max: int }

     

       10
       10
       +
       

     

       11
       11
       +
       (** Raised when a connection error occurs *)

     

       12
       12
       +
       exception ConnectionError of string

     

       13
       13
       +
       

     

       14
       14
       +
       (** Raised when an HTTP error response is received *)

     

       15
       15
       +
       exception HTTPError of {

     

       16
       16
       +
         url: string;

     

       17
       17
       +
         status: int;

     

       18
       18
       +
         reason: string;

     

       19
       19
       +
         body: string option;

     

       20
       20
       +
         headers: Headers.t

     

       21
       21
       +
       }

     

       22
       22
       +
       

     

       23
       23
       +
       (** Raised when authentication fails *)

     

       24
       24
       +
       exception AuthenticationError of string

     

       25
       25
       +
       

     

       26
       26
       +
       (** Raised when there's an SSL/TLS error *)

     

       27
       27
       +
       exception SSLError of string

     

       28
       28
       +
       

     

       29
       29
       +
       (** Raised when proxy connection fails *)

     

       30
       30
       +
       exception ProxyError of string

     

       31
       31
       +
       

     

       32
       32
       +
       (** Raised when content encoding/decoding fails *)

     

       33
       33
       +
       exception EncodingError of string

     

       34
       34
       +
       

     

       35
       35
       +
       (** Raised when an invalid URL is provided *)

     

       36
       36
       +
       exception InvalidURL of string

     

       37
       37
       +
       

     

       38
       38
       +
       (** Raised when request is invalid *)

     

       39
       39
       +
       exception InvalidRequest of string

     

       40
       40
       +
       

     

       41
       41
       +
       (** {1 Error Type} *)

     

       42
       42
       +
       

     

       43
       43
       +
       (** Unified error type for result-based error handling *)

     

       44
       44
       +
       type t = [

     

       45
       45
       +
         | `Timeout

     

       46
       46
       +
         | `TooManyRedirects of string * int * int  (* url, count, max *)

     

       47
       47
       +
         | `ConnectionError of string

     

       48
       48
       +
         | `HTTPError of string * int * string * string option * Headers.t  (* url, status, reason, body, headers *)

     

       49
       49
       +
         | `AuthenticationError of string

     

       50
       50
       +
         | `SSLError of string

     

       51
       51
       +
         | `ProxyError of string

     

       52
       52
       +
         | `EncodingError of string

     

       53
       53
       +
         | `InvalidURL of string

     

       54
       54
       +
         | `InvalidRequest of string

     

       55
       55
       +
         | `UnknownError of string

     

       56
       56
       +
       ]

     

       57
       57
       +
       

     

       58
       58
       +
       (** {1 Conversion Functions} *)

     

       59
       59
       +
       

     

       60
       60
       +
       (** Convert an exception to an error type *)

     

       61
       61
       +
       val of_exn : exn -> t option

     

       62
       62
       +
       

     

       63
       63
       +
       (** Convert an error type to an exception *)

     

       64
       64
       +
       val to_exn : t -> exn

     

       65
       65
       +
       

     

       66
       66
       +
       (** Raise an error as an exception *)

     

       67
       67
       +
       val raise : t -> 'a

     

       68
       68
       +
       

     

       69
       69
       +
       (** {1 Combinators} *)

     

       70
       70
       +
       

     

       71
       71
       +
       (** Wrap a function that may raise exceptions into a result type *)

     

       72
       72
       +
       val catch : (unit -> 'a) -> ('a, t) result

     

       73
       73
       +
       

     

       74
       74
       +
       (** Wrap an async function that may raise exceptions *)

     

       75
       75
       +
       val catch_async : (unit -> 'a) -> ('a, t) result

     

       76
       76
       +
       

     

       77
       77
       +
       (** Map over the success case of a result *)

     

       78
       78
       +
       val map : ('a -> 'b) -> ('a, t) result -> ('b, t) result

     

       79
       79
       +
       

     

       80
       80
       +
       (** Bind for result types with error *)

     

       81
       81
       +
       val bind : ('a -> ('b, t) result) -> ('a, t) result -> ('b, t) result

     

       82
       82
       +
       

     

       83
       83
       +
       (** Applicative operator for combining results *)

     

       84
       84
       +
       val both : ('a, t) result -> ('b, t) result -> ('a * 'b, t) result

     

       85
       85
       +
       

     

       86
       86
       +
       (** Get value or raise the error *)

     

       87
       87
       +
       val get_exn : ('a, t) result -> 'a

     

       88
       88
       +
       

     

       89
       89
       +
       (** Get value or use default *)

     

       90
       90
       +
       val get_or : default:'a -> ('a, t) result -> 'a

     

       91
       91
       +
       

     

       92
       92
       +
       (** Check if error is retryable *)

     

       93
       93
       +
       val is_retryable : t -> bool

     

       94
       94
       +
       

     

       95
       95
       +
       (** Check if error is a client error (4xx) *)

     

       96
       96
       +
       val is_client_error : t -> bool

     

       97
       97
       +
       

     

       98
       98
       +
       (** Check if error is a server error (5xx) *)

     

       99
       99
       +
       val is_server_error : t -> bool

     

       100
       100
       +
       

     

       101
       101
       +
       (** {1 Pretty Printing} *)

     

       102
       102
       +
       

     

       103
       103
       +
       (** Pretty printer for errors *)

     

       104
       104
       +
       val pp : Format.formatter -> t -> unit

     

       105
       105
       +
       

     

       106
       106
       +
       (** Pretty printer for exceptions (falls back to Printexc if not a known exception) *)

     

       107
       107
       +
       val pp_exn : Format.formatter -> exn -> unit

     

       108
       108
       +
       

     

       109
       109
       +
       (** Convert error to string *)

     

       110
       110
       +
       val to_string : t -> string

     

       111
       111
       +
       

     

       112
       112
       +
       (** {1 Syntax Module} *)

     

       113
       113
       +
       

     

       114
       114
       +
       (** Syntax module for let-operators *)

     

       115
       115
       +
       module Syntax : sig

     

       116
       116
       +
         (** Bind operator for result types *)

     

       117
       117
       +
         val ( let* ) : ('a, t) result -> ('a -> ('b, t) result) -> ('b, t) result

     

       118
       118
       +
       

     

       119
       119
       +
         (** Map operator for result types *)

     

       120
       120
       +
         val ( let+ ) : ('a, t) result -> ('a -> 'b) -> ('b, t) result

     

       121
       121
       +
       

     

       122
       122
       +
         (** Both operator for combining results *)

     

       123
       123
       +
         val ( and* ) : ('a, t) result -> ('b, t) result -> ('a * 'b, t) result

     

       124
       124
       +
       end

+56 -26

stack/requests/lib/method.ml

···

       1
       1
       -
       type t = GET | POST | PUT | DELETE | HEAD | OPTIONS | PATCH | CONNECT | TRACE

     

       1
       1
       +
       type t = [

     

       2
       2
       +
         | `GET

     

       3
       3
       +
         | `POST

     

       4
       4
       +
         | `PUT

     

       5
       5
       +
         | `DELETE

     

       6
       6
       +
         | `HEAD

     

       7
       7
       +
         | `OPTIONS

     

       8
       8
       +
         | `PATCH

     

       9
       9
       +
         | `CONNECT

     

       10
       10
       +
         | `TRACE

     

       11
       11
       +
         | `Other of string

     

       12
       12
       +
       ]

     

       2
       13
        
       

     

       3
       14
        
       let to_string = function

     

       4
       4
       -
         | GET -> "GET"

     

       5
       5
       -
         | POST -> "POST"

     

       6
       6
       -
         | PUT -> "PUT"

     

       7
       7
       -
         | DELETE -> "DELETE"

     

       8
       8
       -
         | HEAD -> "HEAD"

     

       9
       9
       -
         | OPTIONS -> "OPTIONS"

     

       10
       10
       -
         | PATCH -> "PATCH"

     

       11
       11
       -
         | CONNECT -> "CONNECT"

     

       12
       12
       -
         | TRACE -> "TRACE"

     

       15
       15
       +
         | `GET -> "GET"

     

       16
       16
       +
         | `POST -> "POST"

     

       17
       17
       +
         | `PUT -> "PUT"

     

       18
       18
       +
         | `DELETE -> "DELETE"

     

       19
       19
       +
         | `HEAD -> "HEAD"

     

       20
       20
       +
         | `OPTIONS -> "OPTIONS"

     

       21
       21
       +
         | `PATCH -> "PATCH"

     

       22
       22
       +
         | `CONNECT -> "CONNECT"

     

       23
       23
       +
         | `TRACE -> "TRACE"

     

       24
       24
       +
         | `Other s -> String.uppercase_ascii s

     

       13
       25
        
       

     

       14
       26
        
       let of_string s =

     

       15
       27
        
         match String.uppercase_ascii s with

     

       16
       16
       -
         | "GET" -> Some GET

     

       17
       17
       -
         | "POST" -> Some POST

     

       18
       18
       -
         | "PUT" -> Some PUT

     

       19
       19
       -
         | "DELETE" -> Some DELETE

     

       20
       20
       -
         | "HEAD" -> Some HEAD

     

       21
       21
       -
         | "OPTIONS" -> Some OPTIONS

     

       22
       22
       -
         | "PATCH" -> Some PATCH

     

       23
       23
       -
         | "CONNECT" -> Some CONNECT

     

       24
       24
       -
         | "TRACE" -> Some TRACE

     

       25
       25
       -
         | _ -> None

     

       28
       28
       +
         | "GET" -> `GET

     

       29
       29
       +
         | "POST" -> `POST

     

       30
       30
       +
         | "PUT" -> `PUT

     

       31
       31
       +
         | "DELETE" -> `DELETE

     

       32
       32
       +
         | "HEAD" -> `HEAD

     

       33
       33
       +
         | "OPTIONS" -> `OPTIONS

     

       34
       34
       +
         | "PATCH" -> `PATCH

     

       35
       35
       +
         | "CONNECT" -> `CONNECT

     

       36
       36
       +
         | "TRACE" -> `TRACE

     

       37
       37
       +
         | other -> `Other other

     

       38
       38
       +
       

     

       39
       39
       +
       let pp ppf m = Format.fprintf ppf "%s" (to_string m)

     

       26
       40
        
       

     

       27
       41
        
       let is_safe = function

     

       28
       28
       -
         | GET | HEAD | OPTIONS | TRACE -> true

     

       29
       29
       -
         | _ -> false

     

       42
       42
       +
         | `GET | `HEAD | `OPTIONS | `TRACE -> true

     

       43
       43
       +
         | `POST | `PUT | `DELETE | `PATCH | `CONNECT | `Other _ -> false

     

       30
       44
        
       

     

       31
       45
        
       let is_idempotent = function

     

       32
       32
       -
         | GET | HEAD | PUT | DELETE | OPTIONS | TRACE -> true

     

       33
       33
       -
         | _ -> false

     

       46
       46
       +
         | `GET | `HEAD | `PUT | `DELETE | `OPTIONS | `TRACE -> true

     

       47
       47
       +
         | `POST | `PATCH | `CONNECT | `Other _ -> false

     

       34
       48
        
       

     

       35
       49
        
       let has_request_body = function

     

       36
       36
       -
         | POST | PUT | PATCH -> true

     

       37
       37
       -
         | _ -> false
     

       50
       50
       +
         | `POST | `PUT | `PATCH -> true

     

       51
       51
       +
         | `GET | `HEAD | `DELETE | `OPTIONS | `CONNECT | `TRACE -> false

     

       52
       52
       +
         | `Other _ -> false  (* Conservative default for unknown methods *)

     

       53
       53
       +
       

     

       54
       54
       +
       let is_cacheable = function

     

       55
       55
       +
         | `GET | `HEAD -> true

     

       56
       56
       +
         | `POST -> true  (* POST can be cacheable with explicit headers *)

     

       57
       57
       +
         | `PUT | `DELETE | `PATCH | `OPTIONS | `CONNECT | `TRACE | `Other _ -> false

     

       58
       58
       +
       

     

       59
       59
       +
       let equal m1 m2 =

     

       60
       60
       +
         match m1, m2 with

     

       61
       61
       +
         | `Other s1, `Other s2 -> String.equal (String.uppercase_ascii s1) (String.uppercase_ascii s2)

     

       62
       62
       +
         | m1, m2 -> m1 = m2

     

       63
       63
       +
       

     

       64
       64
       +
       let compare m1 m2 =

     

       65
       65
       +
         match m1, m2 with

     

       66
       66
       +
         | `Other s1, `Other s2 -> String.compare (String.uppercase_ascii s1) (String.uppercase_ascii s2)

     

       67
       67
       +
         | m1, m2 -> Stdlib.compare m1 m2

+41 -7

stack/requests/lib/method.mli

···

       1
       1
       -
       (** HTTP methods *)

     

       1
       1
       +
       (** HTTP methods following RFC 7231 *)

     

       2
       2
        
       

     

       3
       3
       -
       type t = GET | POST | PUT | DELETE | HEAD | OPTIONS | PATCH | CONNECT | TRACE

     

       3
       3
       +
       (** HTTP method type using polymorphic variants for better composability *)

     

       4
       4
       +
       type t = [

     

       5
       5
       +
         | `GET      (** Retrieve a resource *)

     

       6
       6
       +
         | `POST     (** Submit data to be processed *)

     

       7
       7
       +
         | `PUT      (** Replace a resource *)

     

       8
       8
       +
         | `DELETE   (** Delete a resource *)

     

       9
       9
       +
         | `HEAD     (** Retrieve headers only *)

     

       10
       10
       +
         | `OPTIONS  (** Retrieve allowed methods *)

     

       11
       11
       +
         | `PATCH    (** Partial resource modification *)

     

       12
       12
       +
         | `CONNECT  (** Establish tunnel to server *)

     

       13
       13
       +
         | `TRACE    (** Echo received request *)

     

       14
       14
       +
         | `Other of string  (** Non-standard or extension method *)

     

       15
       15
       +
       ]

     

       16
       16
       +
       

     

       17
       17
       +
       (** {1 Conversion Functions} *)

     

       4
       18
        
       

     

       5
       19
        
       val to_string : t -> string

     

       6
       20
        
       (** Convert method to uppercase string representation *)

     

       7
       21
        
       

     

       8
       8
       -
       val of_string : string -> t option

     

       9
       9
       -
       (** Parse method from string (case-insensitive) *)

     

       22
       22
       +
       val of_string : string -> t

     

       23
       23
       +
       (** Parse method from string (case-insensitive).

     

       24
       24
       +
           Returns [`Other s] for unrecognized methods. *)

     

       25
       25
       +
       

     

       26
       26
       +
       val pp : Format.formatter -> t -> unit

     

       27
       27
       +
       (** Pretty printer for methods *)

     

       28
       28
       +
       

     

       29
       29
       +
       (** {1 Method Properties} *)

     

       10
       30
        
       

     

       11
       31
        
       val is_safe : t -> bool

     

       12
       12
       -
       (** Returns true for safe methods (GET, HEAD, OPTIONS, TRACE) *)

     

       32
       32
       +
       (** Returns true for safe methods (GET, HEAD, OPTIONS, TRACE).

     

       33
       33
       +
           Safe methods should not have side effects. *)

     

       13
       34
        
       

     

       14
       35
        
       val is_idempotent : t -> bool

     

       15
       15
       -
       (** Returns true for idempotent methods (GET, HEAD, PUT, DELETE, OPTIONS, TRACE) *)

     

       36
       36
       +
       (** Returns true for idempotent methods (GET, HEAD, PUT, DELETE, OPTIONS, TRACE).

     

       37
       37
       +
           Idempotent methods can be called multiple times with the same result. *)

     

       16
       38
        
       

     

       17
       39
        
       val has_request_body : t -> bool

     

       18
       18
       -
       (** Returns true for methods that typically have a request body (POST, PUT, PATCH) *)
     

       40
       40
       +
       (** Returns true for methods that typically have a request body (POST, PUT, PATCH) *)

     

       41
       41
       +
       

     

       42
       42
       +
       val is_cacheable : t -> bool

     

       43
       43
       +
       (** Returns true for methods whose responses are cacheable by default (GET, HEAD, POST).

     

       44
       44
       +
           Note: POST is only cacheable with explicit cache headers. *)

     

       45
       45
       +
       

     

       46
       46
       +
       (** {1 Comparison} *)

     

       47
       47
       +
       

     

       48
       48
       +
       val equal : t -> t -> bool

     

       49
       49
       +
       (** Compare two methods for equality *)

     

       50
       50
       +
       

     

       51
       51
       +
       val compare : t -> t -> int

     

       52
       52
       +
       (** Compare two methods for ordering *)

stack/requests/lib/mime.ml

···

       52
       52
        
             in

     

       53
       53
        
             Printf.sprintf "%s; %s" base param_str

     

       54
       54
        
       

     

       55
       55
       +
       let pp ppf t = Format.fprintf ppf "%s" (to_string t)

     

       56
       56
       +
       

     

       55
       57
        
       let charset t =

     

       56
       58
        
         List.assoc_opt "charset" t.parameters

     

       57
       59

stack/requests/lib/mime.mli

···

       9
       9
        
       val to_string : t -> string

     

       10
       10
        
       (** Convert MIME type to string representation *)

     

       11
       11
        
       

     

       12
       12
       +
       val pp : Format.formatter -> t -> unit

     

       13
       13
       +
       (** Pretty printer for MIME types *)

     

       14
       14
       +
       

     

       12
       15
        
       (** Common MIME types *)

     

       13
       16
        
       val json : t

     

       14
       17
        
       val text : t

+2 -7

stack/requests/lib/requests.ml

···

       10
       10
        
       module Body = Body

     

       11
       11
        
       module Response = Response

     

       12
       12
        
       module Client = Client

     

       13
       13
       +
       module Status = Status

     

       14
       14
       +
       module Error = Error

     

       13
       15
        
       module Stream = Stream

     

       14
       16
        
       module Session = Session

     

       15
       17
        
       module Cookie_jar = Cookie_jar

     

       16
       18
        
       module Retry = Retry

     

       17
       17
       -
       module Xdge = Xdge

     

       18
       18
       -
       

     

       19
       19
       -
       (* Re-export exceptions from Stream module *)

     

       20
       20
       -
       exception TimeoutError = Stream.Timeout

     

       21
       21
       -
       exception TooManyRedirects = Stream.TooManyRedirects

     

       22
       22
       -
       exception ConnectionError = Stream.ConnectionError

     

       23
       23
       -
       exception HTTPError = Stream.HTTPError

+2 -8

stack/requests/lib/requests.mli

···

       2
       2
        
       

     

       3
       3
        
       (** {1 Core Types} *)

     

       4
       4
        
       

     

       5
       5
       +
       module Status = Status

     

       5
       6
        
       module Method = Method

     

       6
       7
        
       module Mime = Mime

     

       7
       8
        
       module Headers = Headers

     
···

       11
       12
        
       module Body = Body

     

       12
       13
        
       module Response = Response

     

       13
       14
        
       module Client = Client

     

       15
       15
       +
       module Error = Error

     

       14
       16
        
       

     

       15
       17
        
       (** {1 Streaming Interface} *)

     

       16
       18
        
       

     
···

       21
       23
        
       module Session = Session

     

       22
       24
        
       module Cookie_jar = Cookie_jar

     

       23
       25
        
       module Retry = Retry

     

       24
       24
       -
       module Xdge = Xdge

     

       25
       25
       -
       

     

       26
       26
       -
       (** {1 Exceptions} *)

     

       27
       27
       -
       

     

       28
       28
       -
       exception TimeoutError

     

       29
       29
       -
       exception TooManyRedirects of { url: string; count: int }

     

       30
       30
       -
       exception ConnectionError of string

     

       31
       31
       -
       exception HTTPError of { status: int; body: string; headers: Headers.t }

+2 -2

stack/requests/lib/retry.ml

···

       16
       16
        
         backoff_factor = 0.3;

     

       17
       17
        
         backoff_max = 120.0;

     

       18
       18
        
         status_forcelist = [408; 429; 500; 502; 503; 504];

     

       19
       19
       -
         allowed_methods = Method.[GET; HEAD; PUT; DELETE; OPTIONS; TRACE];

     

       19
       19
       +
         allowed_methods = [`GET; `HEAD; `PUT; `DELETE; `OPTIONS; `TRACE];

     

       20
       20
        
         respect_retry_after = true;

     

       21
       21
        
         jitter = true;

     

       22
       22
        
       }

     
···

       26
       26
        
           ?(backoff_factor = 0.3)

     

       27
       27
        
           ?(backoff_max = 120.0)

     

       28
       28
        
           ?(status_forcelist = [408; 429; 500; 502; 503; 504])

     

       29
       29
       -
           ?(allowed_methods = Method.[GET; HEAD; PUT; DELETE; OPTIONS; TRACE])

     

       29
       29
       +
           ?(allowed_methods = [`GET; `HEAD; `PUT; `DELETE; `OPTIONS; `TRACE])

     

       30
       30
        
           ?(respect_retry_after = true)

     

       31
       31
        
           ?(jitter = true)

     

       32
       32
        
           () =

+9 -9

stack/requests/lib/session.ml

···

       248
       248
        
               ) uri params in

     

       249
       249
        
               Uri.to_string uri

     

       250
       250
        
         in

     

       251
       251
       -
         execute_request t ?headers ?auth ?timeout ~method_:Method.GET url

     

       251
       251
       +
         execute_request t ?headers ?auth ?timeout ~method_:`GET url

     

       252
       252
        
       

     

       253
       253
        
       let post t ?headers ?body ?auth ?timeout ?json ?form url =

     

       254
       254
        
         let body, headers = match json, form, body with

     
···

       270
       270
        
               Some body, Some headers

     

       271
       271
        
           | _, _, body -> body, headers

     

       272
       272
        
         in

     

       273
       273
       -
         execute_request t ?headers ?body ?auth ?timeout ~method_:Method.POST url

     

       273
       273
       +
         execute_request t ?headers ?body ?auth ?timeout ~method_:`POST url

     

       274
       274
        
       

     

       275
       275
        
       let put t ?headers ?body ?auth ?timeout ?json url =

     

       276
       276
        
         let body, headers = match json with

     
···

       282
       282
        
               Some body, Some headers

     

       283
       283
        
           | None -> body, headers

     

       284
       284
        
         in

     

       285
       285
       -
         execute_request t ?headers ?body ?auth ?timeout ~method_:Method.PUT url

     

       285
       285
       +
         execute_request t ?headers ?body ?auth ?timeout ~method_:`PUT url

     

       286
       286
        
       

     

       287
       287
        
       let patch t ?headers ?body ?auth ?timeout ?json url =

     

       288
       288
        
         let body, headers = match json with

     
···

       294
       294
        
               Some body, Some headers

     

       295
       295
        
           | None -> body, headers

     

       296
       296
        
         in

     

       297
       297
       -
         execute_request t ?headers ?body ?auth ?timeout ~method_:Method.PATCH url

     

       297
       297
       +
         execute_request t ?headers ?body ?auth ?timeout ~method_:`PATCH url

     

       298
       298
        
       

     

       299
       299
        
       let delete t ?headers ?auth ?timeout url =

     

       300
       300
       -
         execute_request t ?headers ?auth ?timeout ~method_:Method.DELETE url

     

       300
       300
       +
         execute_request t ?headers ?auth ?timeout ~method_:`DELETE url

     

       301
       301
        
       

     

       302
       302
        
       let head t ?headers ?auth ?timeout url =

     

       303
       303
       -
         execute_request t ?headers ?auth ?timeout ~method_:Method.HEAD url

     

       303
       303
       +
         execute_request t ?headers ?auth ?timeout ~method_:`HEAD url

     

       304
       304
        
       

     

       305
       305
        
       let options t ?headers ?auth ?timeout url =

     

       306
       306
       -
         execute_request t ?headers ?auth ?timeout ~method_:Method.OPTIONS url

     

       306
       306
       +
         execute_request t ?headers ?auth ?timeout ~method_:`OPTIONS url

     

       307
       307
        
       

     

       308
       308
        
       (** {1 Streaming Operations} *)

     

       309
       309
        
       

     

       310
       310
        
       let upload t ?headers ?auth ?timeout ?method_ ?mime ?length ~source url =

     

       311
       311
       -
         let method_ = Option.value method_ ~default:Method.POST in

     

       311
       311
       +
         let method_ = Option.value method_ ~default:`POST in

     

       312
       312
        
         let body = Body.of_stream ?length (Option.value mime ~default:Mime.octet_stream) source in

     

       313
       313
        
         (* TODO: Add progress tracking wrapper around source *)

     

       314
       314
        
         execute_request t ?headers ~body ?auth ?timeout ~method_ url

     

       315
       315
        
       

     

       316
       316
        
       let download t ?headers ?auth ?timeout url ~sink =

     

       317
       317
       -
         let response = execute_request t ?headers ?auth ?timeout ~method_:Method.GET url in

     

       317
       317
       +
         let response = execute_request t ?headers ?auth ?timeout ~method_:`GET url in

     

       318
       318
        
         let body = Response.body response in

     

       319
       319
        
         (* TODO: Add progress tracking wrapper *)

     

       320
       320
        
         Eio.Flow.copy body sink

+362

stack/requests/lib/status.ml

···

       1
       1
       +
       (** HTTP status codes following RFC 7231 and extensions *)

     

       2
       2
       +
       

     

       3
       3
       +
       type informational = [

     

       4
       4
       +
         | `Continue

     

       5
       5
       +
         | `Switching_protocols

     

       6
       6
       +
         | `Processing

     

       7
       7
       +
         | `Early_hints

     

       8
       8
       +
       ]

     

       9
       9
       +
       

     

       10
       10
       +
       type success = [

     

       11
       11
       +
         | `OK

     

       12
       12
       +
         | `Created

     

       13
       13
       +
         | `Accepted

     

       14
       14
       +
         | `Non_authoritative_information

     

       15
       15
       +
         | `No_content

     

       16
       16
       +
         | `Reset_content

     

       17
       17
       +
         | `Partial_content

     

       18
       18
       +
         | `Multi_status

     

       19
       19
       +
         | `Already_reported

     

       20
       20
       +
         | `Im_used

     

       21
       21
       +
       ]

     

       22
       22
       +
       

     

       23
       23
       +
       type redirection = [

     

       24
       24
       +
         | `Multiple_choices

     

       25
       25
       +
         | `Moved_permanently

     

       26
       26
       +
         | `Found

     

       27
       27
       +
         | `See_other

     

       28
       28
       +
         | `Not_modified

     

       29
       29
       +
         | `Use_proxy

     

       30
       30
       +
         | `Temporary_redirect

     

       31
       31
       +
         | `Permanent_redirect

     

       32
       32
       +
       ]

     

       33
       33
       +
       

     

       34
       34
       +
       type client_error = [

     

       35
       35
       +
         | `Bad_request

     

       36
       36
       +
         | `Unauthorized

     

       37
       37
       +
         | `Payment_required

     

       38
       38
       +
         | `Forbidden

     

       39
       39
       +
         | `Not_found

     

       40
       40
       +
         | `Method_not_allowed

     

       41
       41
       +
         | `Not_acceptable

     

       42
       42
       +
         | `Proxy_authentication_required

     

       43
       43
       +
         | `Request_timeout

     

       44
       44
       +
         | `Conflict

     

       45
       45
       +
         | `Gone

     

       46
       46
       +
         | `Length_required

     

       47
       47
       +
         | `Precondition_failed

     

       48
       48
       +
         | `Payload_too_large

     

       49
       49
       +
         | `Uri_too_long

     

       50
       50
       +
         | `Unsupported_media_type

     

       51
       51
       +
         | `Range_not_satisfiable

     

       52
       52
       +
         | `Expectation_failed

     

       53
       53
       +
         | `I_m_a_teapot

     

       54
       54
       +
         | `Misdirected_request

     

       55
       55
       +
         | `Unprocessable_entity

     

       56
       56
       +
         | `Locked

     

       57
       57
       +
         | `Failed_dependency

     

       58
       58
       +
         | `Too_early

     

       59
       59
       +
         | `Upgrade_required

     

       60
       60
       +
         | `Precondition_required

     

       61
       61
       +
         | `Too_many_requests

     

       62
       62
       +
         | `Request_header_fields_too_large

     

       63
       63
       +
         | `Unavailable_for_legal_reasons

     

       64
       64
       +
       ]

     

       65
       65
       +
       

     

       66
       66
       +
       type server_error = [

     

       67
       67
       +
         | `Internal_server_error

     

       68
       68
       +
         | `Not_implemented

     

       69
       69
       +
         | `Bad_gateway

     

       70
       70
       +
         | `Service_unavailable

     

       71
       71
       +
         | `Gateway_timeout

     

       72
       72
       +
         | `Http_version_not_supported

     

       73
       73
       +
         | `Variant_also_negotiates

     

       74
       74
       +
         | `Insufficient_storage

     

       75
       75
       +
         | `Loop_detected

     

       76
       76
       +
         | `Not_extended

     

       77
       77
       +
         | `Network_authentication_required

     

       78
       78
       +
       ]

     

       79
       79
       +
       

     

       80
       80
       +
       type standard = [

     

       81
       81
       +
         | informational

     

       82
       82
       +
         | success

     

       83
       83
       +
         | redirection

     

       84
       84
       +
         | client_error

     

       85
       85
       +
         | server_error

     

       86
       86
       +
       ]

     

       87
       87
       +
       

     

       88
       88
       +
       type t = [

     

       89
       89
       +
         | `Code of int

     

       90
       90
       +
         | standard

     

       91
       91
       +
       ]

     

       92
       92
       +
       

     

       93
       93
       +
       let to_int = function

     

       94
       94
       +
         (* Informational *)

     

       95
       95
       +
         | `Continue -> 100

     

       96
       96
       +
         | `Switching_protocols -> 101

     

       97
       97
       +
         | `Processing -> 102

     

       98
       98
       +
         | `Early_hints -> 103

     

       99
       99
       +
         (* Success *)

     

       100
       100
       +
         | `OK -> 200

     

       101
       101
       +
         | `Created -> 201

     

       102
       102
       +
         | `Accepted -> 202

     

       103
       103
       +
         | `Non_authoritative_information -> 203

     

       104
       104
       +
         | `No_content -> 204

     

       105
       105
       +
         | `Reset_content -> 205

     

       106
       106
       +
         | `Partial_content -> 206

     

       107
       107
       +
         | `Multi_status -> 207

     

       108
       108
       +
         | `Already_reported -> 208

     

       109
       109
       +
         | `Im_used -> 226

     

       110
       110
       +
         (* Redirection *)

     

       111
       111
       +
         | `Multiple_choices -> 300

     

       112
       112
       +
         | `Moved_permanently -> 301

     

       113
       113
       +
         | `Found -> 302

     

       114
       114
       +
         | `See_other -> 303

     

       115
       115
       +
         | `Not_modified -> 304

     

       116
       116
       +
         | `Use_proxy -> 305

     

       117
       117
       +
         | `Temporary_redirect -> 307

     

       118
       118
       +
         | `Permanent_redirect -> 308

     

       119
       119
       +
         (* Client Error *)

     

       120
       120
       +
         | `Bad_request -> 400

     

       121
       121
       +
         | `Unauthorized -> 401

     

       122
       122
       +
         | `Payment_required -> 402

     

       123
       123
       +
         | `Forbidden -> 403

     

       124
       124
       +
         | `Not_found -> 404

     

       125
       125
       +
         | `Method_not_allowed -> 405

     

       126
       126
       +
         | `Not_acceptable -> 406

     

       127
       127
       +
         | `Proxy_authentication_required -> 407

     

       128
       128
       +
         | `Request_timeout -> 408

     

       129
       129
       +
         | `Conflict -> 409

     

       130
       130
       +
         | `Gone -> 410

     

       131
       131
       +
         | `Length_required -> 411

     

       132
       132
       +
         | `Precondition_failed -> 412

     

       133
       133
       +
         | `Payload_too_large -> 413

     

       134
       134
       +
         | `Uri_too_long -> 414

     

       135
       135
       +
         | `Unsupported_media_type -> 415

     

       136
       136
       +
         | `Range_not_satisfiable -> 416

     

       137
       137
       +
         | `Expectation_failed -> 417

     

       138
       138
       +
         | `I_m_a_teapot -> 418

     

       139
       139
       +
         | `Misdirected_request -> 421

     

       140
       140
       +
         | `Unprocessable_entity -> 422

     

       141
       141
       +
         | `Locked -> 423

     

       142
       142
       +
         | `Failed_dependency -> 424

     

       143
       143
       +
         | `Too_early -> 425

     

       144
       144
       +
         | `Upgrade_required -> 426

     

       145
       145
       +
         | `Precondition_required -> 428

     

       146
       146
       +
         | `Too_many_requests -> 429

     

       147
       147
       +
         | `Request_header_fields_too_large -> 431

     

       148
       148
       +
         | `Unavailable_for_legal_reasons -> 451

     

       149
       149
       +
         (* Server Error *)

     

       150
       150
       +
         | `Internal_server_error -> 500

     

       151
       151
       +
         | `Not_implemented -> 501

     

       152
       152
       +
         | `Bad_gateway -> 502

     

       153
       153
       +
         | `Service_unavailable -> 503

     

       154
       154
       +
         | `Gateway_timeout -> 504

     

       155
       155
       +
         | `Http_version_not_supported -> 505

     

       156
       156
       +
         | `Variant_also_negotiates -> 506

     

       157
       157
       +
         | `Insufficient_storage -> 507

     

       158
       158
       +
         | `Loop_detected -> 508

     

       159
       159
       +
         | `Not_extended -> 510

     

       160
       160
       +
         | `Network_authentication_required -> 511

     

       161
       161
       +
         (* Custom code *)

     

       162
       162
       +
         | `Code c -> c

     

       163
       163
       +
       

     

       164
       164
       +
       let of_int = function

     

       165
       165
       +
         (* Informational *)

     

       166
       166
       +
         | 100 -> `Continue

     

       167
       167
       +
         | 101 -> `Switching_protocols

     

       168
       168
       +
         | 102 -> `Processing

     

       169
       169
       +
         | 103 -> `Early_hints

     

       170
       170
       +
         (* Success *)

     

       171
       171
       +
         | 200 -> `OK

     

       172
       172
       +
         | 201 -> `Created

     

       173
       173
       +
         | 202 -> `Accepted

     

       174
       174
       +
         | 203 -> `Non_authoritative_information

     

       175
       175
       +
         | 204 -> `No_content

     

       176
       176
       +
         | 205 -> `Reset_content

     

       177
       177
       +
         | 206 -> `Partial_content

     

       178
       178
       +
         | 207 -> `Multi_status

     

       179
       179
       +
         | 208 -> `Already_reported

     

       180
       180
       +
         | 226 -> `Im_used

     

       181
       181
       +
         (* Redirection *)

     

       182
       182
       +
         | 300 -> `Multiple_choices

     

       183
       183
       +
         | 301 -> `Moved_permanently

     

       184
       184
       +
         | 302 -> `Found

     

       185
       185
       +
         | 303 -> `See_other

     

       186
       186
       +
         | 304 -> `Not_modified

     

       187
       187
       +
         | 305 -> `Use_proxy

     

       188
       188
       +
         | 307 -> `Temporary_redirect

     

       189
       189
       +
         | 308 -> `Permanent_redirect

     

       190
       190
       +
         (* Client Error *)

     

       191
       191
       +
         | 400 -> `Bad_request

     

       192
       192
       +
         | 401 -> `Unauthorized

     

       193
       193
       +
         | 402 -> `Payment_required

     

       194
       194
       +
         | 403 -> `Forbidden

     

       195
       195
       +
         | 404 -> `Not_found

     

       196
       196
       +
         | 405 -> `Method_not_allowed

     

       197
       197
       +
         | 406 -> `Not_acceptable

     

       198
       198
       +
         | 407 -> `Proxy_authentication_required

     

       199
       199
       +
         | 408 -> `Request_timeout

     

       200
       200
       +
         | 409 -> `Conflict

     

       201
       201
       +
         | 410 -> `Gone

     

       202
       202
       +
         | 411 -> `Length_required

     

       203
       203
       +
         | 412 -> `Precondition_failed

     

       204
       204
       +
         | 413 -> `Payload_too_large

     

       205
       205
       +
         | 414 -> `Uri_too_long

     

       206
       206
       +
         | 415 -> `Unsupported_media_type

     

       207
       207
       +
         | 416 -> `Range_not_satisfiable

     

       208
       208
       +
         | 417 -> `Expectation_failed

     

       209
       209
       +
         | 418 -> `I_m_a_teapot

     

       210
       210
       +
         | 421 -> `Misdirected_request

     

       211
       211
       +
         | 422 -> `Unprocessable_entity

     

       212
       212
       +
         | 423 -> `Locked

     

       213
       213
       +
         | 424 -> `Failed_dependency

     

       214
       214
       +
         | 425 -> `Too_early

     

       215
       215
       +
         | 426 -> `Upgrade_required

     

       216
       216
       +
         | 428 -> `Precondition_required

     

       217
       217
       +
         | 429 -> `Too_many_requests

     

       218
       218
       +
         | 431 -> `Request_header_fields_too_large

     

       219
       219
       +
         | 451 -> `Unavailable_for_legal_reasons

     

       220
       220
       +
         (* Server Error *)

     

       221
       221
       +
         | 500 -> `Internal_server_error

     

       222
       222
       +
         | 501 -> `Not_implemented

     

       223
       223
       +
         | 502 -> `Bad_gateway

     

       224
       224
       +
         | 503 -> `Service_unavailable

     

       225
       225
       +
         | 504 -> `Gateway_timeout

     

       226
       226
       +
         | 505 -> `Http_version_not_supported

     

       227
       227
       +
         | 506 -> `Variant_also_negotiates

     

       228
       228
       +
         | 507 -> `Insufficient_storage

     

       229
       229
       +
         | 508 -> `Loop_detected

     

       230
       230
       +
         | 510 -> `Not_extended

     

       231
       231
       +
         | 511 -> `Network_authentication_required

     

       232
       232
       +
         (* Unknown code *)

     

       233
       233
       +
         | c -> `Code c

     

       234
       234
       +
       

     

       235
       235
       +
       let to_string t = string_of_int (to_int t)

     

       236
       236
       +
       

     

       237
       237
       +
       let reason_phrase t =

     

       238
       238
       +
         match t with

     

       239
       239
       +
         (* Informational *)

     

       240
       240
       +
         | `Continue -> "Continue"

     

       241
       241
       +
         | `Switching_protocols -> "Switching Protocols"

     

       242
       242
       +
         | `Processing -> "Processing"

     

       243
       243
       +
         | `Early_hints -> "Early Hints"

     

       244
       244
       +
         (* Success *)

     

       245
       245
       +
         | `OK -> "OK"

     

       246
       246
       +
         | `Created -> "Created"

     

       247
       247
       +
         | `Accepted -> "Accepted"

     

       248
       248
       +
         | `Non_authoritative_information -> "Non-Authoritative Information"

     

       249
       249
       +
         | `No_content -> "No Content"

     

       250
       250
       +
         | `Reset_content -> "Reset Content"

     

       251
       251
       +
         | `Partial_content -> "Partial Content"

     

       252
       252
       +
         | `Multi_status -> "Multi-Status"

     

       253
       253
       +
         | `Already_reported -> "Already Reported"

     

       254
       254
       +
         | `Im_used -> "IM Used"

     

       255
       255
       +
         (* Redirection *)

     

       256
       256
       +
         | `Multiple_choices -> "Multiple Choices"

     

       257
       257
       +
         | `Moved_permanently -> "Moved Permanently"

     

       258
       258
       +
         | `Found -> "Found"

     

       259
       259
       +
         | `See_other -> "See Other"

     

       260
       260
       +
         | `Not_modified -> "Not Modified"

     

       261
       261
       +
         | `Use_proxy -> "Use Proxy"

     

       262
       262
       +
         | `Temporary_redirect -> "Temporary Redirect"

     

       263
       263
       +
         | `Permanent_redirect -> "Permanent Redirect"

     

       264
       264
       +
         (* Client Error *)

     

       265
       265
       +
         | `Bad_request -> "Bad Request"

     

       266
       266
       +
         | `Unauthorized -> "Unauthorized"

     

       267
       267
       +
         | `Payment_required -> "Payment Required"

     

       268
       268
       +
         | `Forbidden -> "Forbidden"

     

       269
       269
       +
         | `Not_found -> "Not Found"

     

       270
       270
       +
         | `Method_not_allowed -> "Method Not Allowed"

     

       271
       271
       +
         | `Not_acceptable -> "Not Acceptable"

     

       272
       272
       +
         | `Proxy_authentication_required -> "Proxy Authentication Required"

     

       273
       273
       +
         | `Request_timeout -> "Request Timeout"

     

       274
       274
       +
         | `Conflict -> "Conflict"

     

       275
       275
       +
         | `Gone -> "Gone"

     

       276
       276
       +
         | `Length_required -> "Length Required"

     

       277
       277
       +
         | `Precondition_failed -> "Precondition Failed"

     

       278
       278
       +
         | `Payload_too_large -> "Payload Too Large"

     

       279
       279
       +
         | `Uri_too_long -> "URI Too Long"

     

       280
       280
       +
         | `Unsupported_media_type -> "Unsupported Media Type"

     

       281
       281
       +
         | `Range_not_satisfiable -> "Range Not Satisfiable"

     

       282
       282
       +
         | `Expectation_failed -> "Expectation Failed"

     

       283
       283
       +
         | `I_m_a_teapot -> "I'm a teapot"

     

       284
       284
       +
         | `Misdirected_request -> "Misdirected Request"

     

       285
       285
       +
         | `Unprocessable_entity -> "Unprocessable Entity"

     

       286
       286
       +
         | `Locked -> "Locked"

     

       287
       287
       +
         | `Failed_dependency -> "Failed Dependency"

     

       288
       288
       +
         | `Too_early -> "Too Early"

     

       289
       289
       +
         | `Upgrade_required -> "Upgrade Required"

     

       290
       290
       +
         | `Precondition_required -> "Precondition Required"

     

       291
       291
       +
         | `Too_many_requests -> "Too Many Requests"

     

       292
       292
       +
         | `Request_header_fields_too_large -> "Request Header Fields Too Large"

     

       293
       293
       +
         | `Unavailable_for_legal_reasons -> "Unavailable For Legal Reasons"

     

       294
       294
       +
         (* Server Error *)

     

       295
       295
       +
         | `Internal_server_error -> "Internal Server Error"

     

       296
       296
       +
         | `Not_implemented -> "Not Implemented"

     

       297
       297
       +
         | `Bad_gateway -> "Bad Gateway"

     

       298
       298
       +
         | `Service_unavailable -> "Service Unavailable"

     

       299
       299
       +
         | `Gateway_timeout -> "Gateway Timeout"

     

       300
       300
       +
         | `Http_version_not_supported -> "HTTP Version Not Supported"

     

       301
       301
       +
         | `Variant_also_negotiates -> "Variant Also Negotiates"

     

       302
       302
       +
         | `Insufficient_storage -> "Insufficient Storage"

     

       303
       303
       +
         | `Loop_detected -> "Loop Detected"

     

       304
       304
       +
         | `Not_extended -> "Not Extended"

     

       305
       305
       +
         | `Network_authentication_required -> "Network Authentication Required"

     

       306
       306
       +
         (* Custom code - provide generic reason based on category *)

     

       307
       307
       +
         | `Code c ->

     

       308
       308
       +
             if c >= 100 && c < 200 then "Informational"

     

       309
       309
       +
             else if c >= 200 && c < 300 then "Success"

     

       310
       310
       +
             else if c >= 300 && c < 400 then "Redirection"

     

       311
       311
       +
             else if c >= 400 && c < 500 then "Client Error"

     

       312
       312
       +
             else if c >= 500 && c < 600 then "Server Error"

     

       313
       313
       +
             else "Unknown"

     

       314
       314
       +
       

     

       315
       315
       +
       (* Classification functions *)

     

       316
       316
       +
       let is_informational t =

     

       317
       317
       +
         let code = to_int t in

     

       318
       318
       +
         code >= 100 && code < 200

     

       319
       319
       +
       

     

       320
       320
       +
       let is_success t =

     

       321
       321
       +
         let code = to_int t in

     

       322
       322
       +
         code >= 200 && code < 300

     

       323
       323
       +
       

     

       324
       324
       +
       let is_redirection t =

     

       325
       325
       +
         let code = to_int t in

     

       326
       326
       +
         code >= 300 && code < 400

     

       327
       327
       +
       

     

       328
       328
       +
       let is_client_error t =

     

       329
       329
       +
         let code = to_int t in

     

       330
       330
       +
         code >= 400 && code < 500

     

       331
       331
       +
       

     

       332
       332
       +
       let is_server_error t =

     

       333
       333
       +
         let code = to_int t in

     

       334
       334
       +
         code >= 500 && code < 600

     

       335
       335
       +
       

     

       336
       336
       +
       let is_error t =

     

       337
       337
       +
         let code = to_int t in

     

       338
       338
       +
         code >= 400 && code < 600

     

       339
       339
       +
       

     

       340
       340
       +
       (* Retry policy functions *)

     

       341
       341
       +
       let is_retryable t =

     

       342
       342
       +
         match t with

     

       343
       343
       +
         | `Request_timeout

     

       344
       344
       +
         | `Too_many_requests

     

       345
       345
       +
         | `Bad_gateway

     

       346
       346
       +
         | `Service_unavailable

     

       347
       347
       +
         | `Gateway_timeout -> true

     

       348
       348
       +
         | _ -> is_server_error t  (* All 5xx errors are generally retryable *)

     

       349
       349
       +
       

     

       350
       350
       +
       let should_retry_on_different_host t =

     

       351
       351
       +
         match t with

     

       352
       352
       +
         | `Bad_gateway

     

       353
       353
       +
         | `Service_unavailable

     

       354
       354
       +
         | `Gateway_timeout -> true

     

       355
       355
       +
         | _ -> false

     

       356
       356
       +
       

     

       357
       357
       +
       (* Pretty printing *)

     

       358
       358
       +
       let pp ppf t =

     

       359
       359
       +
         Format.fprintf ppf "%d" (to_int t)

     

       360
       360
       +
       

     

       361
       361
       +
       let pp_hum ppf t =

     

       362
       362
       +
         Format.fprintf ppf "%d %s" (to_int t) (reason_phrase t)

+161

stack/requests/lib/status.mli

···

       1
       1
       +
       (** HTTP status codes following RFC 7231 and extensions *)

     

       2
       2
       +
       

     

       3
       3
       +
       (** {1 Status Categories} *)

     

       4
       4
       +
       

     

       5
       5
       +
       type informational = [

     

       6
       6
       +
         | `Continue  (** 100 - Client should continue with request *)

     

       7
       7
       +
         | `Switching_protocols  (** 101 - Server is switching protocols *)

     

       8
       8
       +
         | `Processing  (** 102 - Server has received and is processing the request *)

     

       9
       9
       +
         | `Early_hints  (** 103 - Used to return some response headers before final HTTP message *)

     

       10
       10
       +
       ]

     

       11
       11
       +
       (** 1xx Informational responses *)

     

       12
       12
       +
       

     

       13
       13
       +
       type success = [

     

       14
       14
       +
         | `OK  (** 200 - Standard response for successful HTTP requests *)

     

       15
       15
       +
         | `Created  (** 201 - Request has been fulfilled; new resource created *)

     

       16
       16
       +
         | `Accepted  (** 202 - Request accepted, processing pending *)

     

       17
       17
       +
         | `Non_authoritative_information  (** 203 - Request processed, information may be from another source *)

     

       18
       18
       +
         | `No_content  (** 204 - Request processed, no content returned *)

     

       19
       19
       +
         | `Reset_content  (** 205 - Request processed, no content returned, reset document view *)

     

       20
       20
       +
         | `Partial_content  (** 206 - Partial resource return due to request header *)

     

       21
       21
       +
         | `Multi_status  (** 207 - XML, can contain multiple separate responses *)

     

       22
       22
       +
         | `Already_reported  (** 208 - Results previously returned *)

     

       23
       23
       +
         | `Im_used  (** 226 - Request fulfilled, response is instance-manipulations *)

     

       24
       24
       +
       ]

     

       25
       25
       +
       (** 2xx Success responses *)

     

       26
       26
       +
       

     

       27
       27
       +
       type redirection = [

     

       28
       28
       +
         | `Multiple_choices  (** 300 - Multiple options for the resource delivered *)

     

       29
       29
       +
         | `Moved_permanently  (** 301 - This and all future requests directed to the given URI *)

     

       30
       30
       +
         | `Found  (** 302 - Temporary response to request found via alternative URI *)

     

       31
       31
       +
         | `See_other  (** 303 - Response to request found via alternative URI *)

     

       32
       32
       +
         | `Not_modified  (** 304 - Resource has not been modified since last requested *)

     

       33
       33
       +
         | `Use_proxy  (** 305 - Content located elsewhere, retrieve from there (deprecated) *)

     

       34
       34
       +
         | `Temporary_redirect  (** 307 - Connect again to different URI as provided *)

     

       35
       35
       +
         | `Permanent_redirect  (** 308 - Connect again to a different URI using the same method *)

     

       36
       36
       +
       ]

     

       37
       37
       +
       (** 3xx Redirection messages *)

     

       38
       38
       +
       

     

       39
       39
       +
       type client_error = [

     

       40
       40
       +
         | `Bad_request  (** 400 - Request cannot be fulfilled due to bad syntax *)

     

       41
       41
       +
         | `Unauthorized  (** 401 - Authentication is possible but has failed *)

     

       42
       42
       +
         | `Payment_required  (** 402 - Payment required, reserved for future use *)

     

       43
       43
       +
         | `Forbidden  (** 403 - Server refuses to respond to request *)

     

       44
       44
       +
         | `Not_found  (** 404 - Requested resource could not be found *)

     

       45
       45
       +
         | `Method_not_allowed  (** 405 - Request method not supported by that resource *)

     

       46
       46
       +
         | `Not_acceptable  (** 406 - Content not acceptable according to the Accept headers *)

     

       47
       47
       +
         | `Proxy_authentication_required  (** 407 - Client must first authenticate itself with the proxy *)

     

       48
       48
       +
         | `Request_timeout  (** 408 - Server timed out waiting for the request *)

     

       49
       49
       +
         | `Conflict  (** 409 - Request could not be processed because of conflict *)

     

       50
       50
       +
         | `Gone  (** 410 - Resource is no longer available and will not be available again *)

     

       51
       51
       +
         | `Length_required  (** 411 - Request did not specify the length of its content *)

     

       52
       52
       +
         | `Precondition_failed  (** 412 - Server does not meet request preconditions *)

     

       53
       53
       +
         | `Payload_too_large  (** 413 - Request is larger than the server is willing or able to process *)

     

       54
       54
       +
         | `Uri_too_long  (** 414 - URI provided was too long for the server to process *)

     

       55
       55
       +
         | `Unsupported_media_type  (** 415 - Server does not support media type *)

     

       56
       56
       +
         | `Range_not_satisfiable  (** 416 - Client has asked for unprovidable portion of the file *)

     

       57
       57
       +
         | `Expectation_failed  (** 417 - Server cannot meet requirements of Expect request-header field *)

     

       58
       58
       +
         | `I_m_a_teapot  (** 418 - I'm a teapot (RFC 2324) *)

     

       59
       59
       +
         | `Misdirected_request  (** 421 - Request was directed at a server that is not able to produce a response *)

     

       60
       60
       +
         | `Unprocessable_entity  (** 422 - Request unable to be followed due to semantic errors *)

     

       61
       61
       +
         | `Locked  (** 423 - Resource that is being accessed is locked *)

     

       62
       62
       +
         | `Failed_dependency  (** 424 - Request failed due to failure of a previous request *)

     

       63
       63
       +
         | `Too_early  (** 425 - Server is unwilling to risk processing a request that might be replayed *)

     

       64
       64
       +
         | `Upgrade_required  (** 426 - Client should switch to a different protocol *)

     

       65
       65
       +
         | `Precondition_required  (** 428 - Origin server requires the request to be conditional *)

     

       66
       66
       +
         | `Too_many_requests  (** 429 - User has sent too many requests in a given amount of time *)

     

       67
       67
       +
         | `Request_header_fields_too_large  (** 431 - Server is unwilling to process the request *)

     

       68
       68
       +
         | `Unavailable_for_legal_reasons  (** 451 - Resource unavailable for legal reasons *)

     

       69
       69
       +
       ]

     

       70
       70
       +
       (** 4xx Client error responses *)

     

       71
       71
       +
       

     

       72
       72
       +
       type server_error = [

     

       73
       73
       +
         | `Internal_server_error  (** 500 - Generic error message *)

     

       74
       74
       +
         | `Not_implemented  (** 501 - Server does not recognise method or lacks ability to fulfill *)

     

       75
       75
       +
         | `Bad_gateway  (** 502 - Server received an invalid response from upstream server *)

     

       76
       76
       +
         | `Service_unavailable  (** 503 - Server is currently unavailable *)

     

       77
       77
       +
         | `Gateway_timeout  (** 504 - Gateway did not receive response from upstream server *)

     

       78
       78
       +
         | `Http_version_not_supported  (** 505 - Server does not support the HTTP protocol version *)

     

       79
       79
       +
         | `Variant_also_negotiates  (** 506 - Content negotiation for the request results in a circular reference *)

     

       80
       80
       +
         | `Insufficient_storage  (** 507 - Server is unable to store the representation *)

     

       81
       81
       +
         | `Loop_detected  (** 508 - Server detected an infinite loop while processing the request *)

     

       82
       82
       +
         | `Not_extended  (** 510 - Further extensions to the request are required *)

     

       83
       83
       +
         | `Network_authentication_required  (** 511 - Client needs to authenticate to gain network access *)

     

       84
       84
       +
       ]

     

       85
       85
       +
       (** 5xx Server error responses *)

     

       86
       86
       +
       

     

       87
       87
       +
       type standard = [

     

       88
       88
       +
         | informational

     

       89
       89
       +
         | success

     

       90
       90
       +
         | redirection

     

       91
       91
       +
         | client_error

     

       92
       92
       +
         | server_error

     

       93
       93
       +
       ]

     

       94
       94
       +
       (** All standard HTTP status codes *)

     

       95
       95
       +
       

     

       96
       96
       +
       type t = [

     

       97
       97
       +
         | `Code of int  (** Any status code as an integer *)

     

       98
       98
       +
         | standard

     

       99
       99
       +
       ]

     

       100
       100
       +
       (** HTTP status type *)

     

       101
       101
       +
       

     

       102
       102
       +
       (** {1 Conversion Functions} *)

     

       103
       103
       +
       

     

       104
       104
       +
       val to_int : t -> int

     

       105
       105
       +
       (** Convert status to its integer code *)

     

       106
       106
       +
       

     

       107
       107
       +
       val of_int : int -> t

     

       108
       108
       +
       (** Convert an integer to a status *)

     

       109
       109
       +
       

     

       110
       110
       +
       val to_string : t -> string

     

       111
       111
       +
       (** Get the string representation of a status code (e.g., "200", "404") *)

     

       112
       112
       +
       

     

       113
       113
       +
       val reason_phrase : t -> string

     

       114
       114
       +
       (** Get the standard reason phrase for a status code (e.g., "OK", "Not Found") *)

     

       115
       115
       +
       

     

       116
       116
       +
       (** {1 Classification Functions} *)

     

       117
       117
       +
       

     

       118
       118
       +
       val is_informational : t -> bool

     

       119
       119
       +
       (** Check if status code is informational (1xx) *)

     

       120
       120
       +
       

     

       121
       121
       +
       val is_success : t -> bool

     

       122
       122
       +
       (** Check if status code indicates success (2xx) *)

     

       123
       123
       +
       

     

       124
       124
       +
       val is_redirection : t -> bool

     

       125
       125
       +
       (** Check if status code indicates redirection (3xx) *)

     

       126
       126
       +
       

     

       127
       127
       +
       val is_client_error : t -> bool

     

       128
       128
       +
       (** Check if status code indicates client error (4xx) *)

     

       129
       129
       +
       

     

       130
       130
       +
       val is_server_error : t -> bool

     

       131
       131
       +
       (** Check if status code indicates server error (5xx) *)

     

       132
       132
       +
       

     

       133
       133
       +
       val is_error : t -> bool

     

       134
       134
       +
       (** Check if status code indicates any error (4xx or 5xx) *)

     

       135
       135
       +
       

     

       136
       136
       +
       (** {1 Retry Policy} *)

     

       137
       137
       +
       

     

       138
       138
       +
       val is_retryable : t -> bool

     

       139
       139
       +
       (** Check if a status code suggests the request could be retried.

     

       140
       140
       +
           Returns true for:

     

       141
       141
       +
           - 408 Request Timeout

     

       142
       142
       +
           - 429 Too Many Requests

     

       143
       143
       +
           - 502 Bad Gateway

     

       144
       144
       +
           - 503 Service Unavailable

     

       145
       145
       +
           - 504 Gateway Timeout

     

       146
       146
       +
           - Any 5xx errors *)

     

       147
       147
       +
       

     

       148
       148
       +
       val should_retry_on_different_host : t -> bool

     

       149
       149
       +
       (** Check if a status code suggests retrying on a different host might help.

     

       150
       150
       +
           Returns true for:

     

       151
       151
       +
           - 502 Bad Gateway

     

       152
       152
       +
           - 503 Service Unavailable

     

       153
       153
       +
           - 504 Gateway Timeout *)

     

       154
       154
       +
       

     

       155
       155
       +
       (** {1 Pretty Printing} *)

     

       156
       156
       +
       

     

       157
       157
       +
       val pp : Format.formatter -> t -> unit

     

       158
       158
       +
       (** Pretty printer for status codes *)

     

       159
       159
       +
       

     

       160
       160
       +
       val pp_hum : Format.formatter -> t -> unit

     

       161
       161
       +
       (** Human-readable pretty printer that includes both code and reason phrase *)

+11 -15

stack/requests/lib/stream.ml

···

       1
       1
        
       let src = Logs.Src.create "requests.stream" ~doc:"HTTP Request Stream"

     

       2
       2
        
       module Log = (val Logs.src_log src : Logs.LOG)

     

       3
       3
        
       

     

       4
       4
       -
       exception Timeout

     

       5
       5
       -
       exception TooManyRedirects of { url: string; count: int }

     

       6
       6
       -
       exception ConnectionError of string

     

       7
       7
       -
       exception HTTPError of { status: int; body: string; headers: Headers.t }

     

       4
       4
       +
       (* Import Error module exceptions *)

     

       8
       5
        
       

     

       9
       6
        
       (* Helper to get client or use default *)

     

       10
       7
        
       let get_client client =

     
···

       12
       9
        
         | Some c -> c

     

       13
       10
        
         | None -> failwith "No client provided"

     

       14
       11
        
       

     

       15
       15
       -
       (* Convert our Body.t to Cohttp body *)

     

       16
       16
       -
       let body_to_cohttp body = Body.to_cohttp_body body

     

       12
       12
       +
       (* Helper to get client or use default *)

     

       17
       13
        
       

     

       18
       14
        
       (* Convert our Headers.t to Cohttp.Header.t *)

     

       19
       15
        
       let headers_to_cohttp headers =

     
···

       77
       73
        
       

     

       78
       74
        
         let cohttp_headers = headers_to_cohttp headers in

     

       79
       75
        
         let cohttp_body = match body with

     

       80
       80
       -
           | Some b -> body_to_cohttp b

     

       76
       76
       +
           | Some b -> Body.to_cohttp_body b

     

       81
       77
        
           | None -> None

     

       82
       78
        
         in

     

       83
       79
        
       

     
···

       137
       133
        
             let rec follow_redirect url redirects_left =

     

       138
       134
        
               if redirects_left <= 0 then begin

     

       139
       135
        
                 Log.err (fun m -> m "Too many redirects (%d) for %s" max_redirects url);

     

       140
       140
       -
                 raise (TooManyRedirects { url; count = max_redirects })

     

       136
       136
       +
                 raise (Error.TooManyRedirects { url; count = max_redirects; max = max_redirects })

     

       141
       137
        
               end else

     

       142
       138
        
                 (* Get location header from Cohttp headers *)

     

       143
       139
        
                 match Cohttp.Header.get cohttp_resp_headers "location" with

     
···

       184
       180
        
       (* Convenience methods *)

     

       185
       181
        
       let get ~sw ?client ?headers ?auth ?timeout ?follow_redirects ?max_redirects url =

     

       186
       182
        
         request ~sw ?client ?headers ?auth ?timeout ?follow_redirects ?max_redirects

     

       187
       187
       -
           ~method_:Method.GET url

     

       183
       183
       +
           ~method_:`GET url

     

       188
       184
        
       

     

       189
       185
        
       let post ~sw ?client ?headers ?body ?auth ?timeout url =

     

       190
       190
       -
         request ~sw ?client ?headers ?body ?auth ?timeout ~method_:Method.POST url

     

       186
       186
       +
         request ~sw ?client ?headers ?body ?auth ?timeout ~method_:`POST url

     

       191
       187
        
       

     

       192
       188
        
       let put ~sw ?client ?headers ?body ?auth ?timeout url =

     

       193
       193
       -
         request ~sw ?client ?headers ?body ?auth ?timeout ~method_:Method.PUT url

     

       189
       189
       +
         request ~sw ?client ?headers ?body ?auth ?timeout ~method_:`PUT url

     

       194
       190
        
       

     

       195
       191
        
       let delete ~sw ?client ?headers ?auth ?timeout url =

     

       196
       196
       -
         request ~sw ?client ?headers ?auth ?timeout ~method_:Method.DELETE url

     

       192
       192
       +
         request ~sw ?client ?headers ?auth ?timeout ~method_:`DELETE url

     

       197
       193
        
       

     

       198
       194
        
       let head ~sw ?client ?headers ?auth ?timeout url =

     

       199
       199
       -
         request ~sw ?client ?headers ?auth ?timeout ~method_:Method.HEAD url

     

       195
       195
       +
         request ~sw ?client ?headers ?auth ?timeout ~method_:`HEAD url

     

       200
       196
        
       

     

       201
       197
        
       let patch ~sw ?client ?headers ?body ?auth ?timeout url =

     

       202
       202
       -
         request ~sw ?client ?headers ?body ?auth ?timeout ~method_:Method.PATCH url

     

       198
       198
       +
         request ~sw ?client ?headers ?body ?auth ?timeout ~method_:`PATCH url

     

       203
       199
        
       

     

       204
       200
        
       let upload ~sw ?client ?headers ?auth ?timeout ?method_ ?mime ?length

     

       205
       201
        
           ?on_progress ~source url =

     

       206
       206
       -
         let method_ = Option.value method_ ~default:Method.POST in

     

       202
       202
       +
         let method_ = Option.value method_ ~default:`POST in

     

       207
       203
        
         let mime = Option.value mime ~default:Mime.octet_stream in

     

       208
       204
        
       

     

       209
       205
        
         (* Wrap source with progress tracking if callback provided *)

+1 -5

stack/requests/lib/stream.mli

···

       1
       1
        
       (** Streaming HTTP interface *)

     

       2
       2
        
       

     

       3
       3
       -
       (** Exceptions *)

     

       4
       4
       -
       exception Timeout

     

       5
       5
       -
       exception TooManyRedirects of { url: string; count: int }

     

       6
       6
       -
       exception ConnectionError of string

     

       7
       7
       -
       exception HTTPError of { status: int; body: string; headers: Headers.t }

     

       3
       3
       +
       (** Exceptions - re-exported from Error module for backward compatibility *)

     

       8
       4
        
       

     

       9
       5
        
       val request :

     

       10
       6
        
         sw:Eio.Switch.t ->

+19 -1

stack/requests/lib/timeout.ml

···

       24
       24
        
       

     

       25
       25
        
       let connect t = t.connect

     

       26
       26
        
       let read t = t.read

     

       27
       27
       -
       let total t = t.total
     

       27
       27
       +
       let total t = t.total

     

       28
       28
       +
       

     

       29
       29
       +
       let pp ppf t =

     

       30
       30
       +
         let items = [] in

     

       31
       31
       +
         let items = match t.connect with

     

       32
       32
       +
           | Some c -> (Printf.sprintf "connect:%.1fs" c) :: items

     

       33
       33
       +
           | None -> items

     

       34
       34
       +
         in

     

       35
       35
       +
         let items = match t.read with

     

       36
       36
       +
           | Some r -> (Printf.sprintf "read:%.1fs" r) :: items

     

       37
       37
       +
           | None -> items

     

       38
       38
       +
         in

     

       39
       39
       +
         let items = match t.total with

     

       40
       40
       +
           | Some tot -> (Printf.sprintf "total:%.1fs" tot) :: items

     

       41
       41
       +
           | None -> items

     

       42
       42
       +
         in

     

       43
       43
       +
         match items with

     

       44
       44
       +
         | [] -> Format.fprintf ppf "no timeouts"

     

       45
       45
       +
         | _ -> Format.fprintf ppf "%s" (String.concat ", " (List.rev items))

+4 -1

stack/requests/lib/timeout.mli

···

       19
       19
        
       (** Get read timeout *)

     

       20
       20
        
       

     

       21
       21
        
       val total : t -> float option

     

       22
       22
       -
       (** Get total request timeout *)
     

       22
       22
       +
       (** Get total request timeout *)

     

       23
       23
       +
       

     

       24
       24
       +
       val pp : Format.formatter -> t -> unit

     

       25
       25
       +
       (** Pretty printer for timeout configuration *)