Http get

  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
use "http"
use "json"
use "ssl/net"
use "promises"

class JsonRequester
  let _creds: Credentials
  let _sslctx: (SSLContext | None)

  new create(creds: Credentials) =>
    _creds = creds

    _sslctx = try
      recover val
        SSLContext.>set_client_verify(true).>set_authority(None)?
      end
    else
      None
    end

  fun ref apply(url: String,
    receiver: JsonRequesterResultReceiver) ?
  =>
    let valid_url = URL.valid(url)?
    let r = RequestFactory("GET", valid_url, _creds.token)

    let handler_factory = JsonRequesterHandlerFactory(_creds, receiver)
    let client = HTTPClient(_creds.auth, handler_factory, _sslctx)
    client(consume r)?

interface tag JsonRequesterResultReceiver
  be success(json: JsonDoc val)
  be failure(status: U16, response_body: String, message: String)

class JsonRequesterHandlerFactory is HandlerFactory
  let _creds: Credentials
  let _receiver: JsonRequesterResultReceiver

  new val create(creds: Credentials,
    receiver: JsonRequesterResultReceiver)
  =>
    _creds = creds
    _receiver = receiver

  fun apply(session: HTTPSession tag): HTTPHandler ref^ =>
    let requester = JsonRequester(_creds)
    JsonRequesterHandler(requester, _receiver)

class JsonRequesterHandler is HTTPHandler
  let _requester: JsonRequester
  let _receiver: JsonRequesterResultReceiver
  var _payload_body: Array[U8] iso = recover Array[U8] end
  var _status: U16 = 0

  new create(requester: JsonRequester, receiver: JsonRequesterResultReceiver) =>
    _requester = requester
    _receiver = receiver

  fun ref apply(payload: Payload val) =>
    _status = payload.status


    if (_status == 301) or (_status == 307) then
      try
        // Redirect.
        // Let's start a new request to the redirect location
        _requester(payload("Location")?, _receiver)?
        return
      end
    end

    try
      for bs in payload.body()?.values() do
        _payload_body.append(bs)
      end
    end

    if payload.transfer_mode is OneshotTransfer then
      finished()
    end

  fun ref chunk(data: ByteSeq) =>
    _payload_body.append(data)

  fun ref failed(reason: HTTPFailureReason) =>
    let msg = match reason
    | AuthFailed => "Authorization failure"
    | ConnectFailed => "Unable to connect"
    | ConnectionClosed => "Connection was prematurely closed"
    end

    _receiver.failure(_status, "", consume msg)

  fun ref finished() =>
    let x = _payload_body = recover Array[U8] end
    let y: String iso = String.from_iso_array(consume x)

    if _status == 200 then
      try
        let json = recover val
          JsonDoc.>parse(consume y)?
        end
        _receiver.success(json)
      else
        _receiver.failure(_status, "", "Failed to parse response")
      end
    elseif (_status != 301) and (_status != 307) then
      _receiver.failure(_status, consume y, "")
    end