No content requester

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
use courier = "courier"
use "promises"
use ssl = "ssl/net"

interface tag DeleteResultReceiver
  """
  Receives the result of an HTTP request that expects no response body (204 No
  Content). Used for DELETE and PUT operations like deleting a label or starring
  a gist.
  """
  be success()
  be failure(status: U16, response_body: String, message: String)

type DeletedOrError is (Deleted | RequestError)

actor DeletedResultReceiver
  """
  Bridges a DeleteResultReceiver to a Promise[DeletedOrError], fulfilling the
  promise with Deleted on success or a RequestError on failure.
  """
  let _p: Promise[DeletedOrError]

  new create(p: Promise[DeletedOrError]) =>
    _p = p

  be success() =>
    _p(Deleted)

  be failure(status: U16, response_body: String, message: String) =>
    _p(RequestError(status, response_body, message))

primitive Deleted
  """
  Marker type indicating a successful deletion or no-content operation.
  """

actor NoContentRequester is courier.HTTPClientConnectionActor
  """
  Issues an HTTP request that expects a 204 No Content response. Supports
  DELETE and PUT methods. On success, calls `receiver.success()`; on any other
  status or connection failure, calls `receiver.failure()` with details.
  """
  var _http: courier.HTTPClientConnection = courier.HTTPClientConnection.none()
  var _collector: courier.ResponseCollector = courier.ResponseCollector
  let _creds: Credentials
  let _receiver: DeleteResultReceiver
  let _method: courier.Method
  var _request_path: String = ""
  var _status: U16 = 0

  new delete(creds: Credentials,
    url: String,
    receiver: DeleteResultReceiver)
  =>
    """
    Issues an HTTP DELETE request expecting a 204 response.
    """
    _creds = creds
    _receiver = receiver
    _method = courier.DELETE
    _connect(url)

  new put(creds: Credentials,
    url: String,
    receiver: DeleteResultReceiver)
  =>
    """
    Issues an HTTP PUT request with no body, expecting a 204 response. Used for
    operations like starring a gist.
    """
    _creds = creds
    _receiver = receiver
    _method = courier.PUT
    _connect(url)

  fun ref _connect(url: String) =>
    match courier.URL.parse(url)
    | let parsed: courier.ParsedURL =>
      _request_path = parsed.request_path()
      let ctx = match _creds.ssl_ctx
      | let c: ssl.SSLContext val => c
      | None => SSLContextFactory()
      end
      let config = courier.ClientConnectionConfig
      _http = courier.HTTPClientConnection.ssl(
        _creds.auth, ctx, parsed.host, parsed.port,
        this, config)
    | let _: courier.URLParseError =>
      _fail("Unable to parse URL: " + url)
    end

  fun ref _http_client_connection(): courier.HTTPClientConnection =>
    _http

  fun ref on_connected() =>
    let hdrs = recover trn courier.Headers end
    hdrs.set("User-Agent", "Pony GitHub Rest API Client")
    hdrs.set("Accept", "application/vnd.github.v3+json")
    match _creds.token
    | let t: String =>
      (let n, let v) = courier.BearerAuth(t)
      hdrs.set(n, v)
    end
    hdrs.set("Content-Length", "0")
    let request = courier.HTTPRequest(
      _method,
      _request_path,
      consume hdrs)
    _http.send_request(request)

  fun ref on_response(response: courier.Response val) =>
    _status = response.status
    _collector = courier.ResponseCollector
    _collector.set_response(response)

  fun ref on_body_chunk(data: Array[U8] val) =>
    _collector.add_chunk(data)

  fun ref on_response_complete() =>
    _http.close()
    if _status == 204 then
      _receiver.success()
    else
      try
        let response = _collector.build()?
        let body_str = String.from_array(response.body)
        _receiver.failure(_status, consume body_str, "")
      else
        _receiver.failure(_status, "", "")
      end
    end

  fun ref on_connection_failure(reason: courier.ConnectionFailureReason) =>
    let msg = match \exhaustive\ reason
    | courier.ConnectionFailedDNS => "DNS resolution failed"
    | courier.ConnectionFailedTCP => "Unable to connect"
    | courier.ConnectionFailedSSL => "SSL handshake failed"
    | courier.ConnectionFailedTimeout => "Connection timed out"
    end
    _receiver.failure(0, "", consume msg)

  fun ref on_parse_error(err: courier.ParseError) =>
    _http.close()
    _receiver.failure(0, "", "HTTP parse error")

  be _fail(message: String) =>
    _receiver.failure(0, "", message)